Mastering Multithreading in Java: Understanding Threads, Runnable Interface, and Executors with Practical Examples

1. Introduction to Multithreading in Java

Multithreading allows multiple parts of a program to run simultaneously, improving CPU utilization and application responsiveness. Java provides built-in support for multithreading using Thread, Runnable, and Executor frameworks.

2. Creating Threads Using the Thread Class

The simplest way to create a thread is by extending the Thread class and overriding its run() method.

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}
public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

3. Implementing Runnable Interface

Using Runnable is a better approach for separating thread logic from business logic. This allows a class to extend another class if needed.

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable is running.");
    }
}
public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
    }
}

4. Understanding Executors Framework
Executors manage thread creation and pooling. It simplifies thread management and improves performance.

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

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(() -> System.out.println("Task 1 executed"));
        executor.execute(() -> System.out.println("Task 2 executed"));
        executor.shutdown();
    }
}

5. Thread Lifecycle and States
Threads in Java go through various states: New, Runnable, Running, Blocked, and Terminated. Managing thread states helps avoid issues like deadlock 
and improves concurrency control.

6. Best Practices for Using Multithreading
Avoid using Thread.sleep() for synchronization.
Always shut down executors to free resources.
Use synchronization or locks to manage shared resources.
Prefer ExecutorService over manually managing threads.



.