Multithreading in Java

Multithreading in Java allows multiple threads to run concurrently within a single program. In this chapter, we will learn the concepts, benefits, and implementation of multithreading.

What is Multithreading in Java?

Multithreading is a process of executing multiple threads simultaneously within a single program. A thread is the smallest unit of execution in a program, and multithreading allows multiple threads to share the same memory and resources while running concurrently. This improves the performance of programs by making better use of CPU resources and enables tasks such as background processing, parallel computation, and responsive user interfaces.

In Java, multithreading can be implemented by:

1. Extending the Thread class
2. Implementing the Runnable interface

Multithreading Using Extending the Thread Class

You can create a thread by extending the Thread class and overriding its run() method. The run() method contains the code that defines the thread’s task. After creating an object of the subclass, you start the thread using the start() method.

Syntax

The syntax to implement multithreading using extending the Thread class is as follows:

Example

The following example demonstrates creating a thread by extending the Thread class:

Output:

Thread running: 1
Thread running: 2
Thread running: 3
Thread running: 4
Thread running: 5

Explanation:

The run() method contains the code executed by the thread. Calling start() initiates a new thread and executes the run() method concurrently with the main thread.

Multithreading by Implementing the Runnable Interface

Another way to create a thread is by implementing the Runnable interface and providing an implementation for the run() method. You then pass the Runnable object to a Thread object and call start(). This approach can be used when your class is already extending another class.

Syntax

The syntax to implement multithreading by implementing the Runnable interface is as follows:

Example

The following example demonstrates creating a thread by implementing Runnable:

Output:

Thread running: 1
Thread running: 2
Thread running: 3
Thread running: 4
Thread running: 5

Explanation:

By implementing Runnable, the thread’s task is defined in the run() method, and the thread is started by creating a Thread object with the Runnable instance. This approach allows better flexibility and supports multiple inheritance indirectly.

Life Cycle of a Thread in Java Multithreading

In Java, a thread goes through different states from its creation to its termination. To manage the threads in multithreading, it is important to understand the life cycle of a thread (or, a flow of the threads). The main states of a thread are:

1. New (Created): A thread is created but not yet started. It enters this state when you create an object of the Thread class.
2. Runnable: After calling the start() method, the thread becomes ready to run and waits for CPU scheduling. It is now eligible to run but may not be running immediately.
3. Running: When the thread scheduler picks the thread from the runnable pool, it enters the running state and executes its run() method.
4. Waiting/Blocked: A thread can enter a waiting state if it is waiting for another thread to perform a task or release a resource.
5. Timed Waiting: A thread can wait for a specified period using methods like sleep(milliseconds) or join(milliseconds).
6. Terminated (Dead): Once the thread completes its execution or is stopped, it enters the terminated state. A terminated thread cannot be restarted.

Thread Life Cycle Diagram

The following image shows the thread life cycle:

Java Thread Class and Thread Methods

Java provides the Thread class to implement multithreading. The Thread class includes constructors and methods to create, manage, and control threads. It extends the Object class and implements the Runnable interface that allows the threads to be executed concurrently.

Thread Methods

The following are the Thread class methods used for multithreading:

Real-Life Examples of Multithreading

Multithreading is widely used in real-world applications to perform multiple tasks simultaneously. Here are two practical examples:

Example 1: Online Banking Transactions

In online banking systems, multiple users can perform transactions like deposits, withdrawals, and fund transfers at the same time. Each transaction can run on a separate thread that allows the system to process multiple requests concurrently without delays.

The following code demonstrates multithreading in an online banking transaction:

Output:

Deposit started.
Withdrawal started.
Deposit completed.
Withdrawal completed.

Example 2: Web Server Handling Multiple Clients

A web server can handle multiple client requests simultaneously by assigning each request to a separate thread. This ensures that the server remains responsive even when many clients are connected.

The following code demonstrates multithreading for a web server handling multiple clients:

Output:

Client1 request processing started.
Client2 request processing started.
Client1 request processing completed.
Client2 request processing completed.

Advantages of Using Multithreading

Here are some of the advantages of using multithreading:

• Better CPU Utilization:
  With multithreading, multiple threads can run concurrently which allows the CPU to execute several tasks at the same time. In this way, CPU resources are fully utilized, reduces the idle time, and improves overall system performance.
• Faster Execution:
  By running tasks in parallel, multithreading can complete operations much faster than sequential execution. For example, multiple calculations or data-processing tasks can be handled simultaneously, that reduces the total execution time.
• Improved Responsiveness:
  In applications with user interfaces, multithreading allows background tasks to run without freezing the main program. This keeps the application responsive to user input, even while performing heavy processing in the background.
• Resource Sharing:
  Threads within the same process share memory and resources that makes communication and data exchange between tasks simpler and more efficient compared to processes that run independently.
• Background Processing:
  Multithreading allows time-consuming tasks to run in the background without interrupting the main workflow.