Modern applications demand high performance and responsiveness. Whether it’s a server handling thousands of client requests, or a GUI application staying responsive while performing background tasks—concurrency and multithreading are at the heart of such solutions. Java, being one of the earliest mainstream programming languages to support multithreading natively, provides powerful constructs to implement concurrent behavior. This chapter introduces the core concepts of threads, thread life cycle, synchronization, concurrent APIs, and best practices in concurrent programming.

A thread is a lightweight subprocess, the smallest unit of processing. Threads share the same memory space but execute independently.

✅ Key Points:
• Every Java application has at least one thread – the main thread.
• You can create multiple threads to perform tasks in parallel.

There are two primary ways to create threads in Java:
1. Extending the Thread class

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

1. Implementing the Runnable interface

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

A thread in Java can be in one of the following states:
1. New – Created but not yet started.
2. Runnable – Eligible to run, waiting for CPU.
3. Running – Actively executing.
4. Blocked/Waiting – Waiting for a monitor lock or a signal.
5. Terminated – Execution completed or stopped.

Java relies on the JVM and underlying OS for thread scheduling. Threads are assigned priorities (1 to 10) to suggest execution order, but it’s not guaranteed.

t1.setPriority(Thread.MAX_PRIORITY); // 10

When multiple threads access a shared resource (like a variable or object), race conditions may occur. Java provides synchronized blocks and methods to control access.

Example: Synchronized Method

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

Synchronized Block

synchronized(obj) {
    // critical section
}

Java provides methods to facilitate communication between threads:
• wait() – causes the thread to wait.
• notify() – wakes a single waiting thread.
• notifyAll() – wakes all waiting threads.
These must be used within synchronized blocks.

 synchronized(obj) {
    obj.wait();
    obj.notify();
} 

The java.util.concurrent package provides advanced concurrency utilities introduced in Java 5 and beyond.

Important Classes:

• ExecutorService: Thread pool executor
• Future and Callable: Represent async computation
• CountDownLatch: Allows threads to wait until others finish
• Semaphore: Controls access to a resource
• CyclicBarrier: Synchronizes threads at a barrier
• ConcurrentHashMap: Thread-safe map

Example: ExecutorService

ExecutorService executor = Executors.newFixedThreadPool(2);
Runnable task1 = () -> System.out.println("Task 1 running");
Runnable task2 = () -> System.out.println("Task 2 running");
executor.execute(task1);
executor.execute(task2);
executor.shutdown();

Example: Callable and Future

Callable task = () -> {
    Thread.sleep(1000);
    return 123;
};
ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(task);
System.out.println("Result: " + future.get()); // blocks until result is available

Creating too many threads can be expensive. Thread pools manage a pool of reusable threads.

ExecutorService pool = Executors.newFixedThreadPool(5);

Advantages:
• Better resource utilization
• Avoids overhead of thread creation
• Efficient for batch jobs and servers

Issue Description:

• Race Condition: When multiple threads change shared data simultaneously
• Deadlock: Two or more threads are waiting forever for each other
• Starvation: A thread waits indefinitely for a resource
• Livelock: Threads keep changing state but make no progress

Example: Deadlock

 synchronized(obj1) {
     synchronized(obj2) {
         // potential deadlock if another thread does reverse locking
     }
 }

• Minimize shared mutable state.
• Prefer java.util.concurrent over low-level constructs.
• Use thread pools.
• Avoid nested locks to prevent deadlocks.
• Prefer Atomic variables (AtomicInteger, etc.) for counters.

Multithreading and concurrency enable Java programs to perform multiple tasks simultaneously, improving performance and responsiveness. While powerful, concurrency requires careful handling of shared resources, synchronization, and potential pitfalls like race conditions and deadlocks. Java offers both low-level thread APIs and high-level concurrency utilities (ExecutorService, Callable, ConcurrentHashMap, etc.) to help developers write robust multi-threaded applications.