Multithreading in Java

Analogy categoryAnalogies

1. Introduction

Multithreading is the ability of a program to execute multiple parts (threads) of itself concurrently, allowing better utilization of CPU resources. Java has built-in support for multithreading through the java.lang.Thread class and the java.lang.Runnable interface, making it possible to perform tasks like background downloads, UI responsiveness, and parallel computation without blocking the main program flow.

🏏

Cricket analogy: Just as a ground can have the pitch being prepared, the scoreboard being updated, and drinks being carried out all at once by different crew members, Java's Thread and Runnable let a program run background downloads, UI updates, and computations concurrently.

Each Java application starts with at least one thread, called the main thread, which executes the main() method. Additional threads can be spawned from this main thread to run tasks concurrently, and the JVM scheduler decides how these threads share CPU time.

🏏

Cricket analogy: The captain (main thread) walks out first and sets the innings in motion, and any specialist runners (spawned threads) brought on afterward share field time as the umpire (JVM scheduler) allocates it.

2. Syntax

java

// Way 1: Extend the Thread class
class MyThread extends Thread {
    public void run() {
        System.out.println("Running in: " + Thread.currentThread().getName());
    }
}
MyThread t1 = new MyThread();
t1.start();

// Way 2: Implement the Runnable interface
class MyTask implements Runnable {
    public void run() {
        System.out.println("Running in: " + Thread.currentThread().getName());
    }
}
Thread t2 = new Thread(new MyTask());
t2.start();

// Way 2b: Runnable with a lambda expression
Thread t3 = new Thread(() -> System.out.println("Lambda thread running"));
t3.start();

3. Explanation

There are two standard ways to create a thread in Java. The first is extending the Thread class and overriding its run() method; the second is implementing the Runnable interface and passing an instance of it to a Thread constructor. Implementing Runnable is generally the preferred approach because Java supports only single inheritance for classes — if your class already extends another class, you cannot also extend Thread, but you can always implement Runnable. Runnable also cleanly separates the task (what to run) from the thread (how it runs), which is better object-oriented design.

🏏

Cricket analogy: A player who's already contracted to one franchise (extends another class) can't also be "owned" by a second team the way extending Thread would require, but they can freely take on a specific role like "death bowler" (implement Runnable) for any team that hires them.

The single most important distinction to understand is start() versus run(). Calling t.start() asks the JVM to allocate a new call stack and actually create a new thread of execution; the JVM then invokes run() on that new thread. Calling t.run() directly, on the other hand, is nothing special — it is just an ordinary method call that executes on the current thread (e.g., the main thread), with no new thread being created at all.

🏏

Cricket analogy: Calling t.start() is like actually sending a new bowler out to a fresh end of the pitch to bowl their own over, while calling t.run() directly is like the captain just describing the bowling action themselves from where they already stand, no new bowler involved.

Exam trap: calling run() instead of start() compiles and runs fine, but it does NOT create a new thread — the code executes synchronously on the calling thread. Only start() spins up a genuinely new thread of execution. A thread's start() method can also only be called once; calling it a second time throws IllegalThreadStateException.

4. Example

java

public class MultithreadingDemo {

    static class Worker implements Runnable {
        private final String label;
        Worker(String label) { this.label = label; }
        public void run() {
            System.out.println(label + " running on " + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Worker("Task-A"), "Worker-1");
        Thread t2 = new Thread(new Worker("Task-B"), "Worker-2");

        // Using start() creates real new threads
        t1.start();
        t2.start();

        // Wait for both threads to finish before continuing
        t1.join();
        t2.join();

        // Contrast: calling run() directly does NOT create a new thread
        Worker directCall = new Worker("Task-C (direct run())");
        directCall.run();

        System.out.println("Main thread (" + Thread.currentThread().getName() + ") finished.");
    }
}

5. Output

text

Task-A running on Worker-1
Task-B running on Worker-2
Task-C (direct run()) running on main
Main thread (main) finished.

(Note: The order of "Task-A" and "Task-B" lines can vary between runs
because the two threads are scheduled independently by the JVM/OS.)

6. Key Takeaways

A thread can be created by extending Thread or implementing Runnable; implementing Runnable is generally preferred due to Java's single inheritance for classes.
start() creates a genuinely new thread of execution and then internally calls run(); calling run() directly just runs it as a normal synchronous method call.
start() can only be invoked once per Thread object; calling it again throws IllegalThreadStateException.
join() lets one thread wait for another thread to complete before continuing.
Thread execution order across threads is not guaranteed — the JVM scheduler controls interleaving.
Lambda expressions can implement Runnable concisely since it is a functional interface.