What is Multithreading in Java
Multithreading is a technique in programming that allows multiple threads to execute concurrently within a single process. It is an essential concept in Java, a popular programming language used for developing various applications.
Multithreading enables the creation of lightweight processes that can execute simultaneously and independently, allowing for greater efficiency and performance. Each thread has its own stack and program counter, allowing it to execute its own set of instructions.
Java’s support for multithreading is one of its most significant features, making it a popular choice for developing concurrent applications. Multithreading allows for better resource utilization and improves application responsiveness, making it ideal for developing applications that require concurrent processing.
This article will provide a detailed overview of multithreading in Java, including the basics of creating and managing threads, synchronization, thread safety, and handling exceptions.
Understanding Threads in Java
Explanation of Threads:
Threads are small units of execution within a program that can run concurrently with other threads. In Java, threads are represented by the Thread class and are used to perform multiple tasks simultaneously.
Creation of Threads in Java:
By extending the Thread class or implementing the Runnable interface, threads can be formed in Java. Here is an example of creating a thread by extending the Thread class:
import java.lang.Thread;
class MyThread extends Thread {
public void run() {
System.out.println("Executing MyThread...");
for (int i = 1; i <= 5; i++) {
System.out.println("Thread: " + Thread.currentThread().getName() + " Count: " + i);
try {
Thread.sleep(1000); // delay for 1 second
} catch (InterruptedException e) {
System.out.println("Thread interrupted!");
}
}
System.out.println("MyThread execution complete.");
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
System.out.println("Main thread execution complete.");
}
}
Output:
Main thread execution complete.
Executing MyThread…
Thread: Thread-0 Count: 1
Thread: Thread-0 Count: 2
Thread: Thread-0 Count: 3
Thread: Thread-0 Count: 4
Thread: Thread-0 Count: 5
MyThread execution complete.
Life cycle of a Thread:
The life cycle of a thread consists of various stages:
1. New – when a new thread is created but not started yet
2. Runnable – when the thread is executing its task
3. Waiting – when the thread waits for another thread to perform a task
4. Timed Waiting – when a runnable thread enters a waiting state for a specified period of time
5. Terminated or Dead – when a runnable thread completes its task or otherwise terminates
A thread remains in the new state until it’s started, after which it transitions to the runnable state. A thread in the runnable state is considered to be executing its task.
At times, a thread may become waiting for another thread to perform a task. When this happens, the thread won’t be allowed to run until another thread instructs it to do so. In the timed waiting state, a runnable thread can wait for a specific amount of time before transitioning back to the runnable state. When the event it is waiting for happens, the thread might also return to the runnable state. After a runnable thread completes its task or terminates, it will enter the terminated state.
Thread States:
Threads can be in one of several states, such as New, Runnable, Blocked, Waiting, Timed Waiting, or Terminated. Here is an example of a thread in the Runnable state:
import java.lang.Thread;
public class ThreadStatesExample {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
public void run() {
try {
System.out.println("Thread is in the Running state");
Thread.sleep(2000); // sleep for 2 seconds
System.out.println("Thread is in the Terminated state");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
System.out.println("Thread is in the Ready");
thread.start(); // start the thread and put it in the Runnable state
System.out.println("Thread is in the Runnable state");
}
}
Output:
Thread is in the Ready
Thread is in the Runnable state
Thread is in the Running state
Thread is in the Terminated state
In the code above, we create a new thread and pass it to a Runnable instance. The run method of a Runnable instance puts the thread to sleep for 2 seconds. This is done before printing a message indicating that the thread has entered the Terminated state.
The output shows that the thread begins in the Ready state. It then moves to the Runnable state when the ‘start’ method is called. When the thread begins executing the code in the ‘run’ method, it transitions to the Running state. Finally, it enters the Terminated state when the code in the ‘run’ method finishes executing.
Thread Synchronization:
Thread synchronization is used to control access to shared resources by multiple threads. This can be achieved by using synchronized methods or synchronized blocks.
Here is an example of using synchronized blocks:
import java.lang.Thread;
class MyObject {
private int count = 0;
public void increment() {
synchronized(this) {
count++;
}
}
public int getCount() {
synchronized(this) {
return count;
}
}
}
public class ThreadSynchronizationExample {
public static void main(String[] args) throws InterruptedException {
MyObject obj = new MyObject();
Thread thread1 = new Thread(new Runnable() {
public void run() {
obj.increment();
}
});
Thread thread2 = new Thread(new Runnable() {
public void run() {
obj.increment();
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(obj.getCount()); // Output: 2
}
}
Output:
2
In the above code, we have defined a MyObject class with two synchronized methods: increment() and getCount(). The increment() method increments the count variable in a synchronized block, while the getCount() method returns the count value in a synchronized block. This ensures that only one thread can access the count variable at a time and prevents race conditions.
In the ThreadSynchronizationExample class, we create two threads, thread1 and thread2, and start them using the start() method. Both threads call the increment() method on the same MyObject instance. Since the increment() method is synchronized, only one thread can access it at a time. As a result, the count variable is incremented twice, and its value becomes 2.
We then use the join() method to wait for both threads to finish before printing the count value using the getCount() method. The output of the program is 2, which is the expected value.
Types of Threads in Java
In Java, there are three types of threads – User Thread, Daemon Thread, and Non-Daemon Thread.
User threads are created to perform tasks that are essential to the program. These threads continue to run until the program terminates or until the task is completed. User threads can be created by extending the Thread class or implementing the Runnable interface.
Daemon threads, on the other hand, are used to perform tasks in the background that do not require user intervention. Daemon threads are automatically terminated when all user threads have completed their execution. They are created by setting the thread as a daemon thread using the setDaemon() method.
Non-Daemon threads are threads that are not daemon threads. They are user threads that continue to run even if the main program terminates. These threads can be used to perform tasks that require long periods of execution, such as file transfers or network connections.
Here’s an example code that demonstrates the use of all three types of threads in Java:
import java.lang.Thread;
public class ThreadTypesExample {
public static void main(String[] args) {
Thread userThread = new Thread(new Runnable() {
public void run() {
System.out.println("User thread running");
}
});
Thread daemonThread = new Thread(new Runnable() {
public void run() {
while (true) {
System.out.println("Daemon thread running");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
daemonThread.setDaemon(true);
userThread.start();
daemonThread.start();
Thread nonDaemonThread = new Thread(new Runnable() {
public void run() {
try {
System.out.println("Non-daemon thread running");
Thread.sleep(5000);
System.out.println("Non-daemon thread completed");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
nonDaemonThread.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Main thread completed");
}
}
Output:
User thread running
Daemon thread running
Non-daemon thread running
Daemon thread running
Daemon thread running
Main thread completed
Daemon thread running
Daemon thread running
Non-daemon thread completed
Daemon thread running
Thread Pools
Explanation of Thread Pools
A thread pool is a collection of pre-initialized threads that are ready to perform tasks. Instead of creating a new thread for each task, we can make use of a thread pool to execute the tasks. Thread pools are used to reduce the overhead of thread creation and destruction.
Creating Thread Pools in Java
Java provides the Executor framework to create and manage thread pools. We can create a thread pool using the Executors class.
Here’s an example:
ExecutorService executorService = Executors.newFixedThreadPool(5);
In this example, we are creating a thread pool with a fixed size of 5 threads.
Advantages of Thread Pools
There are several advantages of using thread pools:
- Thread reuse: Threads are reused to perform tasks, which reduces the overhead of thread creation and destruction.
- Better performance: Thread pools provide better performance than creating a new thread for each task.
- Load management: Thread pools can manage the number of threads to use, depending on the load of the application.
- Scalability: Thread pools can be easily scaled by adjusting the size of the pool.
Here’s an example that demonstrates the use of a thread pool in Java:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
executorService.execute(new Runnable() {
public void run() {
System.out.println("Task executed by thread: " + Thread.currentThread().getName());
}
});
}
executorService.shutdown();
}
}
Output:
Task executed by thread: pool-1-thread-1
Task executed by thread: pool-1-thread-5
Task executed by thread: pool-1-thread-2
Task executed by thread: pool-1-thread-3
Task executed by thread: pool-1-thread-2
Task executed by thread: pool-1-thread-5
Task executed by thread: pool-1-thread-4
Task executed by thread: pool-1-thread-1
Task executed by thread: pool-1-thread-2
Task executed by thread: pool-1-thread-3
In this example, we are creating a thread pool with a fixed size of 5 threads. We are then executing 10 tasks using the execute() method of the ExecutorService interface. The tasks are executed by the threads in the thread pool. Once all the tasks are completed, we shut down the thread pool using the shutdown() method.
Executors
Overview of Executors
In Java, Executors are used to create and manage threads. They provide a layer of abstraction between the developer and the details of thread creation and management, making it easier to work with threads.
Creating Executors in Java
To create an Executor, we use the Executors class, which provides several factory methods for creating different types of executors. Here’s an example of creating a new cached thread pool executor:
ExecutorService executor = Executors.newCachedThreadPool
Different Types of Executors in Java
There are several different types of Executors available in Java, including:
CachedThreadPoolExecutor: A thread pool executor that creates new threads as needed but will reuse previously created threads when they are available.
FixedThreadPoolExecutor: A thread pool executor that creates a fixed number of threads when it is created and then reuses those threads for subsequent tasks.
SingleThreadExecutor: A thread pool executor that creates a single thread to execute tasks and then reuses that thread for subsequent tasks.
Here’s an example of creating a new fixed thread pool executor with 5 threads:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorsExample {
public static void main(String[] args) {
// CachedThreadPoolExecutor
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
cachedThreadPool.execute(new Runnable() {
public void run() {
System.out.println("Task " + index + " executed by thread: " + Thread.currentThread().getName());
}
});
}
cachedThreadPool.shutdown();
// FixedThreadPoolExecutor
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
public void run() {
System.out.println("Task " + index + " executed by thread: " + Thread.currentThread().getName());
}
});
}
fixedThreadPool.shutdown();
// SingleThreadExecutor
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
System.out.println("Task " + index + " executed by thread: " + Thread.currentThread().getName());
}
});
}
singleThreadExecutor.shutdown();
}
}
Output:
Task 6 executed by thread: pool-1-thread-7
Task 9 executed by thread: pool-1-thread-10
Task 2 executed by thread: pool-1-thread-3
Task 1 executed by thread: pool-2-thread-2
Task 0 executed by thread: pool-3-thread-1
Task 0 executed by thread: pool-2-thread-1
Task 2 executed by thread: pool-2-thread-3
Task 1 executed by thread: pool-3-thread-1
Task 5 executed by thread: pool-2-thread-2
Task 5 executed by thread: pool-1-thread-6
Task 4 executed by thread: pool-1-thread-5
Task 1 executed by thread: pool-1-thread-2
Task 8 executed by thread: pool-1-thread-9
Task 3 executed by thread: pool-1-thread-4
Task 8 executed by thread: pool-2-thread-2
Task 0 executed by thread: pool-1-thread-1
Task 2 executed by thread: pool-3-thread-1
Task 7 executed by thread: pool-2-thread-1
Task 6 executed by thread: pool-2-thread-3
Task 4 executed by thread: pool-2-thread-5
Task 3 executed by thread: pool-2-thread-4
Task 3 executed by thread: pool-3-thread-1
Task 9 executed by thread: pool-2-thread-2
Task 7 executed by thread: pool-1-thread-8
Task 4 executed by thread: pool-3-thread-1
Task 5 executed by thread: pool-3-thread-1
Task 6 executed by thread: pool-3-thread-1
Task 7 executed by thread: pool-3-thread-1
Task 8 executed by thread: pool-3-thread-1
Task 9 executed by thread: pool-3-thread-1
Thread Interference
Explanation of Thread Interference
Thread interference occurs when two or more threads try to access and modify the same data concurrently, leading to data inconsistency and unexpected behavior. This problem occurs in multi-threaded programs and is a critical issue that needs to be addressed.
Race Conditions
A race condition occurs when two or more threads try to modify the same data at the same time, leading to unpredictable results. Race conditions occur when the execution order of threads is not deterministic.
Data Inconsistency
Data inconsistency is a common problem that arises due to thread interference. It occurs when the data accessed by multiple threads is not consistent or in the expected state. Inconsistencies can lead to incorrect results and bugs in the program.
Synchronization in Java
Synchronization is the process of controlling access to shared resources in a multi-threaded environment. Java provides several mechanisms for synchronization, such as synchronized blocks and methods and the volatile keyword.
Here’s an example of synchronization in Java:
import java.lang.Thread;
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Count: " + counter.getCount()); // Output: 2000
}
}
Output:
Count: 2000
In the above example, we use the ‘synchronized’ keyword to ensure that only one thread can access the ‘increment’ and ‘getCount’ methods at a time. As a result, the counter is incremented correctly, and the final value of the counter is as expected.
Best Practices for Multithreading in Java
Multithreading is an essential aspect of Java programming, and to write robust and efficient code, it’s important to follow some best practices.
Here are some of the best practices to consider:
- Thread Safety: Thread safety is critical when working with multithreading in Java. It’s important to ensure that shared resources are accessed in a synchronized manner to prevent race conditions and data inconsistencies. Synchronized methods and blocks can be used to achieve thread safety in Java.
- Avoiding Deadlocks: Deadlocks occur when two or more threads are blocked, waiting for each other to release the resources they need. To avoid deadlocks, follow the “Acquire and Release” principle. A thread should acquire all the resources it needs before it starts executing. The thread should release the resources once it’s done. Additionally, it’s important to avoid holding locks for an extended period and to use timeouts and interruption mechanisms to prevent deadlocks.
- Using the Right Synchronization Techniques: In Java, there are different synchronization techniques available, including synchronized methods, synchronized blocks, and volatile variables. It’s important to use the appropriate synchronization technique based on the specific scenario to achieve optimal performance.
- Writing Efficient Code: Writing efficient code is critical when working with multithreading in Java. It’s important to minimize the amount of time a thread spends waiting and to ensure that threads have sufficient work to do. Additionally, it’s important to use thread pools and executors to manage threads efficiently and to avoid creating too many threads that could lead to performance issues.
Following these best practices can help you write efficient, robust, and reliable multithreaded Java code that can scale to meet the needs of your application.
Conclusion
In this article, we have discussed the concept of multithreading in Java, which allows us to execute multiple threads concurrently. We covered the different types of threads, including user, daemon, and non-daemon threads. We then discussed thread pools and executors, which can help optimize the use of threads in our application. Next, we explored thread interference and synchronization in Java, including how to use synchronization to prevent race conditions and data inconsistency.
Finally, we covered some best practices for multithreading in Java, including ensuring thread safety, avoiding deadlocks, using the right synchronization techniques, and writing efficient code.
Multithreading is essential in Java as it allows us to perform multiple tasks simultaneously, which can greatly improve the performance of our applications. Multithreading is useful for applications that involve I/O operations, such as network communication or disk access. One thread can wait for I/O operations to complete while another thread continues to execute. In addition, multithreading can help us take advantage of multi-core processors, which are becoming increasingly common in modern computers.
Multithreading is a powerful tool in Java that can help us improve the performance of our applications. However, it also introduces new challenges, such as thread interference and synchronization. Understanding the concepts of multithreading can lead to efficient and scalable code. Following best practices is also important in utilizing the benefits of multithreading.