Introduction to Multithreading

In Java, multithreading is the capability of a CPU, or a single core in a multi-core processor, to provide multiple threads of execution concurrently. Because modern applications often perform many tasks simultaneously, an efficient multithreading mechanism helps utilize the system resources optimally.

Threads are the smallest unit of processing that can be scheduled by the operating system. In Java, every application starts with a single thread, known as the main thread. Java supports multithreading by allowing multiple threads to be created and run simultaneously.

Why Use Multithreading?

1. Resource Utilization: Multithreading maximizes CPU usage by performing multiple operations at once.
2. Improved Performance: Tasks that are independent of one another can run concurrently, leading to a faster overall execution time.
3. Responsive Applications: In user interface applications, multitasking can prevent the application from freezing during long computations.

Creating Threads in Java

In Java, you can create threads in two primary ways: by extending the Thread class or by implementing the Runnable interface.

1. Extending the Thread Class

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        thread1.start(); // Starts the thread
        
        MyThread thread2 = new MyThread();
        thread2.start(); // Start another thread
    }
}

In this example, a new thread class (MyThread) extends the Thread class and overrides the run method to define the thread's behavior. Threads are started using the start() method, which invokes the run() method in a new thread of execution.

2. Implementing the Runnable Interface

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable thread is running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start(); // Start the Runnable thread

        Thread thread2 = new Thread(new MyRunnable());
        thread2.start(); // Start another Runnable thread
    }
}

In this example, by implementing the Runnable interface, you separate the task (the code inside run()) from the thread management (the code inside main()). This approach is preferred when you need to extend a different class as Java restricts multiple inheritance.

Thread Life Cycle

A thread in Java can be in one of the following states:

1. New: A thread that is created but not started yet.
2. Runnable: A thread that is ready to run and is waiting for CPU allocation.
3. Blocked: A thread that is blocked waiting for a monitor lock (e.g., when trying to access a synchronized method).
4. Waiting: A thread that is waiting indefinitely for another thread to perform a particular action (ex: using wait() method).
5. Timed Waiting: A thread that is waiting for another thread to perform an action for up to a specified waiting time (ex: using sleep()).
6. Terminated: A thread that has exited after completing its task.

Visual Representation:

New -> Runnable -> (Running) -> Terminated
           |     ^
           |     |
           |-----| (Waiting)

Synchronization: Maintaining Consistency

When multiple threads access shared resources or mutable data, it can lead to inconsistent states or race conditions. To manage access to these resources, Java provides synchronized methods and synchronized blocks.

Synchronized Methods

class Counter {
    private int count = 0;
    
    // Synchronized method
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

By marking the increment method as synchronized, you ensure that only one thread can execute this method at any given time, thus maintaining the integrity of the count variable.

Synchronized Blocks

If you need to synchronize access to a block of code rather than an entire method, you can use a synchronized block.

class Counter {
    private int count = 0;

    public void increment() {
        synchronized (this) { // synchronized block
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

Tips on Using Synchronization:

• Use synchronization judiciously, as excessive synchronization can lead to reduced performance.
• Try to keep synchronized blocks small to minimize the time a thread holds a lock.

The Executor Framework: Higher Level of Concurrency

Java provides the Executor framework to ease multithreading by abstracting the thread management complexities. This framework allows you to manage a pool of threads easily, which can be reused for different tasks.

Example of Using ThreadPoolExecutor

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        // Create a thread pool with 3 threads
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 10; i++) {
            executor.submit(new RunnableTask(i));
        }

        executor.shutdown(); // Shutdown the executor
    }
}

class RunnableTask implements Runnable {
    private final int taskId;

    public RunnableTask(int taskId) {
        this.taskId = taskId;
    }

    public void run() {
        System.out.println("Thread " + Thread.currentThread().getName() + " executing task " + taskId);
    }
}

In this example, we create a thread pool of fixed size (3 threads) and submit 10 tasks to it. The executor manages the thread scheduling and resource allocation for us, making it much simpler to handle multiple threads.

Conclusion

Java's multithreading capabilities offer a wide range of tools to improve application performance and responsiveness. From basic thread creation to advanced synchronization and the Executor framework, Java provides everything needed to build robust applications that can handle multiple tasks simultaneously. Understanding these concepts will empower you to write more efficient and effective Java applications that take full advantage of concurrent programming techniques.