What is Multithreading in Java?

Expected Interview Answer

Step-by-Step Explanation

1. Step 1

   Understand a thread

   A thread is a lightweight unit of execution with its own stack and program counter but shared heap and static memory.

2. Step 2

   Create the thread

   Extend Thread or, preferably, implement Runnable/Callable and hand the task to a Thread or ExecutorService.

3. Step 3

   Start execution

   Call start() (never run() directly) so the JVM allocates a new thread and invokes run() on it.

4. Step 4

   Let the scheduler run threads

   The OS/JVM scheduler time-slices runnable threads across available cores, interleaving or parallelizing them.

5. Step 5

   Coordinate shared state

   Use synchronized, locks, volatile, or concurrent collections to prevent race conditions and visibility bugs.

6. Step 6

   Join or shut down

   Use join() to wait for completion, or shutdown() an ExecutorService to release the thread pool cleanly.

Code Example

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

public class MultithreadingDemo {
    public static void main(String[] args) throws InterruptedException {
        // 1) Manual thread using a Runnable
        Runnable task = () -> {
            String name = Thread.currentThread().getName();
            System.out.println("Running on: " + name);
        };
        Thread t = new Thread(task, "worker-1");
        t.start();   // start(), NOT run()
        t.join();    // wait for it to finish

        // 2) Preferred: a pool of reusable threads
        ExecutorService pool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            int id = i;
            pool.submit(() -> System.out.println("Task " + id
                + " on " + Thread.currentThread().getName()));
        }
        pool.shutdown();
    }
}

Follow-up Questions

• What is the difference between a process and a thread?
• How do concurrency and parallelism differ?
• Why prefer ExecutorService over creating threads manually?
• What is the difference between Runnable and Callable?
• What problems can arise from sharing mutable state across threads?