Multithreading in Java — Learn with Examples

Introduction to Multithreading in Java

Multithreading is a programming concept that allows concurrent execution of multiple threads within a single Java program. Threads are lightweight sub-processes that share the same resources (like memory space) of the main process but execute independently. Multithreading is used to improve the performance and responsiveness of Java applications, especially in scenarios where tasks can be executed in parallel.

Creating Threads in Java

In Java, there are two main ways to create threads:

1. Extending the Thread class

java
class MyThread extends Thread {
    @Override
    public void run() {
        // Code to be executed in the thread
        System.out.println("Thread is running!");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // Starts the thread's execution
    }
}

Explanation: In this example, we create a thread by extending the Thread class and overriding its run() method. The run() method contains the code that will be executed when the thread is started. We then create an instance of the MyThread class and start the thread using the start() method.

2. Implementing the Runnable interface

java
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // Code to be executed in the thread
        System.out.println("Thread is running!");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // Starts the thread's execution
    }
}

Explanation: In this example, we create a thread by implementing the Runnable interface, which requires us to provide an implementation for the run() method. We then create an instance of the MyRunnable class and pass it to a new Thread object. Finally, we start the thread using the start() method.

Thread Synchronization

When multiple threads access shared resources concurrently, it can lead to data inconsistencies and errors. To avoid this, Java provides synchronization mechanisms:

1. Synchronized Method

java
class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

Explanation: In this example, we have a Counter class with increment() and getCount() methods. By marking these methods as synchronized, we ensure that only one thread can execute them at a time, preventing race conditions and maintaining data integrity.

2. Synchronized Block

java
class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

Explanation: This example achieves the same synchronization effect as the previous one, but instead of synchronizing entire methods, we use synchronized blocks to encapsulate the critical sections of code.

Thread Communication

Threads often need to communicate with each other to coordinate their actions. Java provides methods like wait(), notify(), and notifyAll() for this purpose.

java
class Message {
    private String content;
    private boolean empty = true;

    public synchronized String read() {
        while (empty) {
            try {
                wait(); // Wait until a message is available
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = true;
        notifyAll(); // Notify waiting threads that the buffer is empty
        return content;
    }

    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait(); // Wait until the buffer is empty
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = false;
        this.content = message;
        notifyAll(); // Notify waiting threads that a message is available
    }
}

Explanation: In this example, we create a Message class that allows one thread to write a message while another thread reads it. The read() and write() methods are synchronized, and they use wait() and notifyAll() to coordinate the communication between the reading and writing threads.

Conclusion

Multithreading in Java provides a powerful way to improve the performance and responsiveness of applications. However, it also introduces challenges like thread synchronization and communication. By understanding the concepts and using proper synchronization techniques, you can create robust and efficient multithreaded Java applications.

Remember to handle exceptions and gracefully terminate threads when they are no longer needed to avoid resource leaks and unexpected behavior. Always test your multithreaded code thoroughly to identify and resolve potential issues.