DEV Community

Vidhi Jayswal
Vidhi Jayswal

Posted on

Multithreading in Java : A Deep Dive

#java #softwaredevelopment #multithreading #programming

Multithreading is the concurrent execution of two or more threads, allowing programs to perform multiple tasks simultaneously. In Java, each thread represents an independent flow of control. Thread is a lightweight, independent unit of execution, and multithreading enables the efficient utilization of system resources, leading to improved performance and responsiveness in applications.

Primary reasons to use multithreading in Java:

  1. Concurrency: Concurrent execution allows multiple tasks to progress simultaneously, enhancing overall system throughput.
  2. Responsiveness: Multithreading prevents a single, time-consuming task from blocking the entire program, ensuring that other threads can continue execution.
  3. Resource Utilization: Takes advantage of multi-core processors, maximizing the utilization of available hardware resources.

Thread Creation: Threads can be created by extending the 'Thread' class or implementing the 'Runnable' interface. Threads share the same process but have their own stack and program counter.

Creating Threads in Java:

  1. Extending Thread Class:

Java code:

class MyThread extends Thread 
{
    public void run() 
    {

    }
}

// Creating and starting the thread
MyThread myThread = new MyThread();
myThread.start();
Enter fullscreen mode Exit fullscreen mode
  1. Implementing Runnable Interface: Implementing the 'Runnable' interface is a more flexible approach, enabling developer to extend other classes as well.

Java Code:

class MyRunnable implements Runnable 
{
    public void run() 
    {

    }
}

// Creating and starting the thread
Thread myThread = new Thread(new MyRunnable());
myThread.start();
Enter fullscreen mode Exit fullscreen mode

Thread States and Lifecycle: A thread in Java goes through various states in its lifecycle.

New: The thread is created but not yet started.
Runnable: The thread is ready to run and waiting for the CPU.
Blocked: The thread is waiting for a monitor lock to enter a synchronized block or method.
Waiting: The thread is waiting for another thread to perform a specific action.
Timed Waiting: Similar to waiting, but with a specified time limit.
Terminated: The thread has completed its execution.

Synchronization in multithreading: Concurrency issues arise when multiple threads access shared resources simultaneously. Synchronization ensures that only one thread can access a resource at a time. It is achieved using the 'synchronized' keyword.

Java Code:

class SharedResource 
{
    private int count = 0;
    public synchronized void increment() 
    {
        count++;
    }
}
Enter fullscreen mode Exit fullscreen mode

Conclusion:
Multithreading in Java is a powerful tool for developing efficient and responsive applications. Understanding thread creation, synchronization, and best practices is crucial for harnessing the full potential of multithreading while avoiding common pitfalls.

Top comments (1)

Collapse
 
dhanush9952 profile image
Dhanush • • Edited

Example program for Multithreading:

In this example we have created thread by extending Thread class and overriding run() method of Runnable interface. Also the Thread class implements Runnable interface.
run() is the only method in Runnable interface. So, it is a functional interface.

class MultithreadingDemo extends Thread {
    public void run() {
        try {
            System.out.println("Thread " + Thread.currentThread().getId() + " is running");
        } catch (Exception e) {
            System.out.println("Exception is caught");
        }
    }
}

public class Multithreading {
    public static void main(String[] args) {
        int n = 8; // Number of threads
        for (int i = 0; i < n; i++) {
            MultithreadingDemo object = new MultithreadingDemo();
            object.start();
        }
    }

}
Enter fullscreen mode Exit fullscreen mode

Output: (varies each time) 

Thread 20 is running
Thread 22 is running
Thread 23 is running
Thread 24 is running
Thread 25 is running
Thread 26 is running
Thread 27 is running
Thread 21 is running
Enter fullscreen mode Exit fullscreen mode

Since Runnable is a functional interface, there is no need of implementing Runnable interface, we can write the program using lambda experssion:

public class Multithreading {
    public static void main(String[] args) {
        int n = 8; // Number of threads
        for (int i = 0; i < n; i++) {
            Thread thread = new Thread(() -> {
                try {
                    System.out.println("Thread " + Thread.currentThread().getId() + " is running");
                } catch (Exception e) {
                    System.out.println("Exception is caught");
                }
            });
            thread.start();
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Read next

crusty0gphr profile image

My Everyday Tools

Harutyun Mardirossian -

thisweekinjavascript profile image

Claude AI now runs JavaScript, Python beats JavaScript on GitHub, new Node.js versions and more

James -

thenjdevopsguy profile image

Why WASM: Quickstart

Michael Levan -

rym_michaut profile image

9 Open-Source Tools to Build Better Data Apps in 2025

Rym -