The Ultimate Guide to Java Multithreading for Scalable Application – Copy

// Method 1: Extending Thread class
class MyThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " - Thread 1, iteration " + i);
}
}
}
// Method 2: Implementing Runnable interface
class MyThread2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " - Thread 2, iteration " + i);
}
}
}
public class ThreadExample {
public static void main(String[] args) {
// Method 1: Create and start a thread by extending the Thread class
MyThread1 thread1 = new MyThread1();
thread1.setName("Thread-1");
thread1.start();

main - Main thread, iteration 0
Thread-1 - Thread 1, iteration 0
Thread-2 - Thread 2, iteration 0
main - Main thread, iteration 1
Thread-1 - Thread 1, iteration 1
Thread-2 - Thread 2, iteration 1
main - Main thread, iteration 2
Thread-1 - Thread 1, iteration 2
Thread-2 - Thread 2, iteration 2
main - Main thread, iteration 3
Thread-1 - Thread 1, iteration 3
Thread-2 - Thread 2, iteration 3
main - Main thread, iteration 4
Thread-1 - Thread 1, iteration 4
Thread-2 - Thread 2, iteration 4

public class CinemaBooking {
public static void main(String[] args) {
// Create a stack with a capacity of 5 (seats available for booking)
Stack stack = new Stack(5);
// Create two threads: one for pushing (booking seats) and one for popping (cancelling or removing a booking)
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10; i++) {
stack.push(100); // Simulate booking a seat
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10; i++) {
stack.pop(); // Simulate cancelling a booking or removing a seat
}
});

This will produce output like:
Seat booked, remaining seats: 4
Seat booked, remaining seats: 3
Seat cancelled, remaining seats: 4
Seat booked, remaining seats: 3

public class Stack {
private int top = -1;private int[] stack = new int[5];
// Lock object for synchronization
private final Object lock = new Object();

Explanation of the Code:

1. Synchronized Block: In the push and pop methods, a synchronized block is used with a specific lock object (lock). This ensures that only one thread can execute either of these methods at any time.
2. Synchronized Method: In the pushAlt method, the synchronized keyword is used directly in the method signature, which synchronizes the entire method. The lock used behind the scenes is the instance of the object (this).
3. Static Synchronized Method: The staticMethod is synchronized using the class lock. Since it’s a static method, we use the class object as the lock, ensuring that only one thread can execute this method at a time across all instances.

Important Notes:

• If a thread is inside a synchronized method or block, other threads that want to execute synchronized methods or blocks on the same lock will have to wait.
• Static methods are synchronized on the class object (not this), meaning that the lock is shared across all instances of the class.

Thread Locking and Synchronization

When a thread acquires an object lock, it blocks any other thread from accessing the same shared resource until it relinquishes the lock. If a thread cannot immediately acquire the lock, it is blocked and must wait for the lock to become available. Once a thread exits a synchronized block, the lock is released. However, the program should not assume the order in which locks are granted, as this depends on the platform’s CPU scheduling.

You might wonder why the sleep() method is used. This increases the chances of a thread being interrupted or corrupted by another thread while the first one is sleeping. This demonstrates how concurrency can lead to unexpected behavior if synchronization is not handled correctly.

Static vs Instance Synchronized Methods

If a class contains both static synchronized methods and synchronized instance methods, they operate independently. The static synchronized method locks on the class object, while the instance methods lock on individual objects. This means they can run simultaneously on different threads because they don’t share the same lock.

Moreover, when a subclass overrides a synchronized method from its superclass, it can choose whether to maintain the synchronization. This allows for flexibility in thread safety depending on the subclass’s requirements.

Race Condition and Synchronization

A race condition occurs when multiple threads simultaneously access and modify a shared variable, leading to an inconsistent state. For example, consider a stack where multiple threads try to push and pop elements at the same time. Without proper synchronization, the stack’s state can become corrupted, resulting in errors like an ArrayIndexOutOfBoundsException. This can be prevented by using synchronized methods or blocks, ensuring that only one thread modifies the stack at a time.

Synchronized Blocks and Explicit Locks

In a synchronized block, you need to pass an explicit lock. If this lock is null, a NullPointerException will be thrown. A synchronized block allows finer control over which resources to lock, providing more flexibility than synchronizing the entire method.

Thread Safety

Thread safety refers to the design of classes that maintain consistency and correctness when multiple threads access them concurrently. For example, StringBuffer is thread-safe, whereas StringBuilder is not. Designing thread-safe classes is crucial when dealing with shared data to avoid inconsistencies.

Volatile Keyword in Java

The volatile keyword in Java ensures that a variable’s value is directly read from and written to main memory, bypassing thread-local caches. This is crucial in multi-threaded environments, where multiple threads may access and modify a shared variable. Without volatile, threads could be working with stale data from their local caches, leading to inconsistencies.

For example, consider two threads working with a shared boolean flag. If thread 1 changes the flag in its local cache and does not update it in the main memory, thread 2 may still read the old value from its cache. By declaring the flag as volatile, we ensure that all threads see the latest value, preventing inconsistent behavior.

Singleton Pattern and Volatile Keyword

In the Singleton design pattern, only one instance of a class is allowed. To prevent multiple threads from creating new instances, we use synchronization. However, without the volatile keyword, multiple threads might still create separate instances due to caching issues, violating the Singleton pattern. Declaring the instance as volatile ensures that all threads access the most up-to-date value of the instance, thereby maintaining the Singleton constraint.

Example Code for Singleton Pattern

public class TVSet {
private static volatile TVSet instance;
private TVSet() {
// Private constructor to prevent instantiation
}
public static TVSet getInstance() {
if (instance == null) {
synchronized (TVSet.class) {
if (instance == null) {
instance = new TVSet();
}
}
}
return instance;
}
}

In this example, the TVSet class uses the volatile keyword for the instance variable to ensure that the latest instance is visible to all threads, even if they are reading from their local caches. Without volatile, there could be a situation where multiple threads simultaneously create new instances, breaking the Singleton pattern.

Producer-Consumer Problem

The producer-consumer problem involves a queue where multiple threads can either produce items or consume them. Synchronization is crucial here to prevent multiple threads from accessing the queue simultaneously, leading to inconsistencies. The solution typically involves using wait/notify mechanisms or blocking queues to manage the flow of data between producer and consumer threads efficiently.

Here’s a simple implementation of the Producer-Consumer problem using Java. In this code, a producer thread produces items and adds them to a queue, while a consumer thread consumes items from the queue. The wait() and notify() mechanisms are used for synchronization to ensure that producers don’t add items when the queue is full and consumers don’t try to consume items when the queue is empty.

import java.util.LinkedList;
import java.util.Queue;
class SharedQueue {
private final int MAX_CAPACITY = 10;
private final Queue<Integer> queue = new LinkedList<>();
// Method for producer to add an item to the queue
public synchronized void produce(int item) throws InterruptedException {
while (queue.size() == MAX_CAPACITY) {
wait(); // Wait until the queue has space
}
queue.add(item);
System.out.println("Produced: " + item);
notify(); // Notify the consumer that there's an item available
}
// Method for consumer to remove an item from the queue
public synchronized int consume() throws InterruptedException {
while (queue.isEmpty()) {
wait(); // Wait until the queue has an item
}
int item = queue.poll();
System.out.println("Consumed: " + item);
notify(); // Notify the producer that there's space in the queue
return item;
}
}

class Producer extends Thread {
private final SharedQueue sharedQueue;

public Producer(SharedQueue sharedQueue) {
this.sharedQueue = sharedQueue;
}

@Override
public void run() {
try {
for (int i = 1; i <= 20; i++) {
sharedQueue.produce(i);
Thread.sleep(100); // Simulating time taken to produce
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}

class Consumer extends Thread {
private final SharedQueue sharedQueue;

public Consumer(SharedQueue sharedQueue) {
this.sharedQueue = sharedQueue;
}

@Override
public void run() {
try {
for (int i = 1; i <= 20; i++) {
sharedQueue.consume();
Thread.sleep(150); // Simulating time taken to consume
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}

public class ProducerConsumerExample {
public static void main(String[] args) {
SharedQueue sharedQueue = new SharedQueue();

Producer producer = new Producer(sharedQueue);
Consumer consumer = new Consumer(sharedQueue);

producer.start();
consumer.start();
}
}

Blocking Queue Implementation and Thread Synchronization

We are going to implement a blocking queue with two types of threads: one set of threads will try to push items into the queue, while the other set will try to remove items. In this multi-threaded environment, only one thread can access the queue at a time to maintain thread safety. To achieve this, we will use synchronization to control access to the queue and ensure that threads don’t interfere with each other.

Queue Initialization and Synchronization

We will create a queue and initialize it with a maximum capacity. The queue is implemented using a LinkedList. We will implement two methods: one for adding items (add()) and one for removing items (remove()). Both methods will be synchronized to prevent race conditions.

public class BlockingQueue {
private LinkedList<Integer> queue;
private int capacity;
public BlockingQueue(int capacity) {
this.capacity = capacity;
this.queue = new LinkedList<>();
}
public synchronized boolean add(int item) {
if (queue.size() == capacity) {
return false; // Queue is full
}
queue.add(item);
return true;
}
public synchronized int remove() {
if (queue.size() == 0) {
return -1; // Queue is empty
}
return queue.remove();
}
}

Synchronization Using Locks

In the add() and remove() methods, synchronization is required to ensure that multiple threads do not concurrently access the queue, as this could lead to inconsistencies. The queue object itself is used as a lock to ensure that only one thread can access the critical section at any time.

Handling Full and Empty Queues

In the add() method, before adding an item, we check if the queue is full. If it is, the thread must wait until space is available. Similarly, in the remove() method, if the queue is empty, the thread must wait until an item is added. To manage this, we use the wait() and notifyAll() methods from the Object class.

Waiting for Space or Items

If a thread cannot add or remove an item due to the queue’s state (full or empty), it will wait for the condition to be true (i.e., when space becomes available or an item is added). When space is freed up or an item is added, the thread will be notified using the notifyAll() method.

public synchronized boolean add(int item) throws InterruptedException {
while (queue.size() == capacity) {
wait(); // Wait until there is space
}
queue.add(item);
notifyAll(); // Notify all threads waiting for space
return true;
}
public synchronized int remove() throws InterruptedException {
while (queue.size() == 0) {
wait(); // Wait until an item is available
}
int item = queue.remove();
notifyAll(); // Notify all threads waiting for an item
return item;
}

Thread Communication

In the add() and remove() methods, the wait() method is used to block the thread if the queue is full (in the case of the add() method) or empty (in the case of the remove() method). These threads are then notified when the condition changes, such as when space becomes available or an item is added/removed.

• The add() method uses wait() if the queue is full and notifyAll() when an item is added.
• The remove() method uses wait() if the queue is empty and notifyAll() when an item is removed.

Handling Multiple Threads Trying to Access the Queue

In a multi-threaded environment, multiple threads can compete to access the queue. The wait() method allows threads to wait for a condition (like space being available) before attempting to execute further. However, to avoid the “spurious wakeup” problem where a thread wakes up without the condition being met, we use a while loop instead of an if statement. This ensures that the thread will check the condition again after being notified.

public synchronized boolean add(int item) throws InterruptedException {
while (queue.size() == capacity) {
wait(); // Wait until there is space
}
queue.add(item);
notifyAll(); // Notify all waiting threads
return true;
}
public synchronized int remove() throws InterruptedException {
while (queue.size() == 0) {
wait(); // Wait until an item is available
}
int item = queue.remove();
notifyAll(); // Notify all waiting threads
return item;
}

Summary

• BlockingQueue: A queue that blocks threads if they try to add an item when it’s full or remove an item when it’s empty.
• Synchronization: We use synchronization to ensure that only one thread can modify the queue at a time.
• Thread Communication: Threads are blocked using wait() and are notified using notifyAll() when they can resume execution. The while loop ensures that threads recheck the conditions after being notified.

Thread States and Transitions in Java

In Java, when a thread is created, it starts in the “new” state. Once the start() method is called, it transitions into the “ready to run” state. After being scheduled by the operating system, the thread enters the “running” state. When the run() method completes, the thread enters the “dead” state. Once a thread is dead, it cannot be started again.

Non-Runnable States: Sleeping and Blocked

A thread can enter several non-runnable states. For instance, when the Thread.sleep() method is called, the thread enters the “sleeping” state, where it is not executing but still holds any locks it acquired. The thread will remain in the sleeping state until the specified time elapses or another thread interrupts it.

Another non-runnable state is the “blocked” state, which occurs when a thread is waiting for some external input or resource. Threads can also be blocked when they are trying to acquire a lock on a synchronized block or method.

Waiting and Lock Acquisition States

When a thread calls wait(), it enters a “waiting” state. If the thread receives a notification (via notify() or notifyAll()), it does not immediately return to the “running” state. Instead, it enters the “blocked for lock acquisition” state, where it waits to acquire the lock needed to proceed. Once the lock is acquired, the thread transitions to the “ready to run” state and can resume execution.

Thread States Enum

Java provides a Thread.State enum that helps track the state of a thread. The possible states include:

• NEW: The thread has been created but has not started.
• RUNNABLE: The thread is ready and waiting to be scheduled by the JVM.
• BLOCKED: The thread is waiting for a lock to proceed.
• WAITING: The thread is waiting indefinitely for another thread to perform a particular action.
• TIMED_WAITING: The thread is waiting for a specific amount of time (e.g., in Thread.sleep()).
• TERMINATED: The thread has finished executing.

The state of a thread can be checked using the Thread.getState() method, which returns a value from the Thread.State enum.

Thread State Transitions

Consider a thread that is running. If it calls sleep(), it will transition to the “sleeping” state. When the sleep time is over, the thread will return to the “ready to run” state. Similarly, when a thread enters a loop, it can be in the “running” state, and once it terminates, it will enter the “terminated” state.

The main method of the program can repeatedly check and print the state of the thread until it reaches the “terminated” state, at which point the program exits.

Yield Method

The Thread.yield() method suggests that the current thread gives up its remaining time slice and allows other threads to execute. However, calling yield() is just a hint to the JVM, and there is no guarantee that the current thread will immediately be moved to the “ready to run” state.

Sleep and Interrupted Exceptions

When Thread.sleep() is called, the thread goes into the “sleeping” state for a specified time. If the sleep duration completes, the thread moves to the “ready to run” state. If another thread interrupts the sleeping thread, it will immediately move back to the “ready to run” state and throw an InterruptedException when it resumes execution. This is why the sleep() method should always be enclosed in a try-catch block to handle interruptions.

Similarly, when a thread calls wait() and another thread calls notify(), the waiting thread moves to the “blocked for lock acquisition” state, where it must compete for the lock before resuming execution.

Waiting, Notifying, and Interrupted States

When a thread is in the “waiting for notification” state, it can be awakened by one of three events:

1. Another thread calls notify() or notifyAll().
2. The specified time in the wait(long timeout) method has elapsed.
3. Another thread interrupts the waiting thread.

When a thread is awakened, it does not immediately enter the “ready to run” state. Instead, it first enters the “blocked for lock acquisition” state, where it must acquire the lock before it can proceed.

Handling Interrupted Exceptions

A thread in the “waiting” state can be interrupted by another thread, causing it to transition to the “blocked for lock acquisition” state. Once the thread gets a chance to run, it will throw an InterruptedException. Therefore, any code that calls wait() or sleep() should be wrapped in a try-catch block to handle this exception.

Difference Between Timed-Out and Interrupted Threads

The key difference between a thread being interrupted and a thread timing out is that when a thread is interrupted, it will immediately throw an InterruptedException when it resumes. However, if a thread is merely timed out (for example, by passing a timeout to the wait() method), it does not know whether it was notified or if the time elapsed. There is no exception thrown in the case of a timeout, and the thread proceeds normally once the timeout period has passed.

Code Example for Thread States

The following example demonstrates the different states of a thread using Thread.getState():

class ThreadStateExample extends Thread {
public void run() {
try {
Thread.sleep(1000); // Sleep for 1 second
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ThreadStateExample thread = new ThreadStateExample();
System.out.println("Thread state before start: " + thread.getState()); // NEW
thread.start();
while (thread.isAlive()) {
System.out.println("Thread state: " + thread.getState());
try {
Thread.sleep(500); // Sleep for half a second
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Thread state after completion: " + thread.getState()); // TERMINATED
}
}

Conclusion

In summary, threads in Java transition between various states based on the actions they perform (such as sleep(), wait(), notify(), or acquiring locks). By understanding these states, you can write more efficient and controlled multi-threaded applications. It is also crucial to handle interruptions properly, especially when using methods like sleep() and wait(), to ensure that threads behave as expected and do not get stuck indefinitely.

Thread Join in Java

The thread.join() method is used to make one thread wait for another thread to complete before continuing its execution. When join() is called on a thread, the current thread is blocked until the thread on which join() was called finishes its execution. This ensures that the calling thread (usually the main thread) waits for the child thread to complete before it proceeds. If a time is specified in join(), the main thread will wait only for that amount of time for the child thread to complete. After this time has elapsed, the main thread will resume execution regardless of whether the child thread has finished.

public class ThreadJoinExample {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Child Thread Executing");
}
}, "Child Thread");
t.start(); // Start the thread
try {
t.join(); // Main thread will wait for the child thread to finish
} catch (InterruptedException e) {
System.out.println("Main Thread Interrupted");
}
System.out.println("Main Thread Exiting");
}
}

Thread Priorities in Java

In Java, each thread has a priority, which can be set using setPriority(int priority) and checked with getPriority(). Thread priorities influence the thread scheduling mechanism, but the behavior can depend on the platform and JVM implementation. Java’s default thread priority is Thread.NORM_PRIORITY (which equals 5). The minimum priority is Thread.MIN_PRIORITY (1), and the maximum is Thread.MAX_PRIORITY (10). However, setting the thread priority is advisory, and there is no guarantee that the JVM will honor it. This behavior may vary between platforms.

public class ThreadPriorityExample {
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
System.out.println("Thread 1 Executing");
});
thread1.setPriority(Thread.MAX_PRIORITY); // Setting high priority
System.out.println("Thread 1 Priority: " + thread1.getPriority());
thread1.start();
}
}

Thread Scheduling in Java

Thread scheduling refers to how the JVM allocates CPU time to different threads. It is highly dependent on the underlying operating system. There are two common scheduling strategies:

1. Preemptive Scheduling: If a thread with a higher priority becomes ready to run, the current running thread may be preempted to allow the higher priority thread to execute.

2. Time-Sliced (Round Robin) Scheduling: The scheduler allocates CPU time to threads in fixed time slices, ensuring that all threads are given a chance to execute.

In either case, Java provides no guarantee that thread priorities or scheduling strategies will be followed exactly as specified. JVM implementations can vary.

public class ThreadSchedulingExample {
public static void main(String[] args) {
Thread thread1 = new Thread(() -> System.out.println("Thread 1 Executing"));
Thread thread2 = new Thread(() -> System.out.println("Thread 2 Executing"));
thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);
thread1.start();thread2.start();
}
}

Deadlock in Java

A deadlock occurs when two or more threads are blocked forever because each one is waiting for the other to release a resource. A common deadlock scenario involves two threads that hold locks on different resources and are waiting for each other to release them.

Here’s an example to create a deadlock situation:

public class DeadlockExample {
private static final Object lock1 = new Object();
private static final Object lock2 = new Object();
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (lock1) {
System.out.println("Thread 1: Holding lock 1...");
try { Thread.sleep(50); } catch (InterruptedException e) {}
synchronized (lock2) {
System.out.println("Thread 1: Acquired lock 2");
}
}
});
Thread thread2 = new Thread(() -> {
synchronized (lock2) {
System.out.println("Thread 2: Holding lock 2...");
try { Thread.sleep(50); } catch (InterruptedException e) {}
synchronized (lock1) {
System.out.println("Thread 2: Acquired lock 1");
}
}
});
thread1.start();
thread2.start();
}
}

Deadlock Prevention

To prevent deadlocks, ensure that threads acquire locks in a consistent order. If both threads always acquire the locks in the same order, deadlocks can be avoided. Here’s how you can avoid the deadlock in the above example:

public class DeadlockPreventionExample {
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (lock1) {
System.out.println("Thread 1: Holding lock 1...");
try { Thread.sleep(50); } catch (InterruptedException e) {}
synchronized (lock2) {
System.out.println("Thread 1: Acquired lock 2");
}
}
});Thread thread2 = new Thread(() -> {
synchronized (lock1) { // Acquire lock1 first
System.out.println("Thread 2: Holding lock 1...");
try { Thread.sleep(50); } catch (InterruptedException e) {}
synchronized (lock2) { // Then acquire lock2
System.out.println("Thread 2: Acquired lock 2");
}
}
});
thread1.start();
thread2.start();
}
}