Java Multithreading & Concurrency

Multithreading is a powerful feature in Java that allows concurrent execution of multiple parts of a program for maximum CPU utilization.

Understanding Threads

What is a Thread?

A thread is a lightweight process, the smallest unit of processing that can be scheduled by an operating system. Java supports multithreading through the java.lang.Thread class.

Program vs Process vs Thread:

Program: Static code (set of instructions)
Process: Running instance of a program with its own memory space
Thread: Lightweight sub-process within a process, shares memory

Thread Lifecycle

Thread States
State Transitions

NEW: Thread created but not started
RUNNABLE: Thread ready to run or running
BLOCKED: Waiting for monitor lock
WAITING: Waiting indefinitely for another thread
TIMED_WAITING: Waiting for specified time
TERMINATED: Thread completed execution

Thread thread = new Thread(() -> {
    System.out.println("Running");
});

System.out.println(thread.getState()); // NEW
thread.start();
System.out.println(thread.getState()); // RUNNABLE
thread.join();
System.out.println(thread.getState()); // TERMINATED

Creating Threads

Method 1: Extending Thread Class

public class MyThread extends Thread {
    private String threadName;
    
    public MyThread(String name) {
        this.threadName = name;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(threadName + ": " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// Usage
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread("Thread-1");
        MyThread thread2 = new MyThread("Thread-2");
        
        thread1.start();
        thread2.start();
    }
}

Method 2: Implementing Runnable Interface (Recommended)

Implementing Runnable is preferred because it allows your class to extend another class and promotes better design.

public class MyRunnable implements Runnable {
    private String taskName;
    
    public MyRunnable(String name) {
        this.taskName = name;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(taskName + ": " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

// Usage
public class RunnableDemo {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable("Task-1"));
        Thread thread2 = new Thread(new MyRunnable("Task-2"));
        
        thread1.start();
        thread2.start();
    }
}

Method 3: Using Lambda Expressions (Java 8+)

public class LambdaThreadDemo {
    public static void main(String[] args) {
        // Using lambda expression
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Lambda Thread: " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        thread.start();
    }
}

Thread Synchronization

The Problem: Race Conditions

Understanding Race Conditions

A race condition occurs when multiple threads access shared data concurrently, leading to unpredictable results.

public class Counter {
    private int count = 0;
    
    // UNSAFE - Race condition
    public void increment() {
        count++;  // Not atomic: read-modify-write
    }
    
    public int getCount() {
        return count;
    }
}

// Problem demonstration
public class RaceConditionDemo {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) counter.increment();
        });
        
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) counter.increment();
        });
        
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        
        System.out.println("Count: " + counter.getCount());
        // Expected: 2000, Actual: Often less due to race condition
    }
}

Solution 1: Synchronized Methods

public class SynchronizedCounter {
    private int count = 0;
    
    // SAFE - synchronized method
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

Solution 2: Synchronized Blocks

Synchronized blocks provide finer-grained control over synchronization, improving performance by locking only critical sections.

public class SynchronizedBlockExample {
    private int count = 0;
    private Object lock = new Object();
    
    public void increment() {
        synchronized (lock) {
            count++;
        }
    }
    
    // Synchronized on this object
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
}

Solution 3: Locks (java.util.concurrent.locks)

ReentrantLock
ReadWriteLock

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();  // Always unlock in finally
        }
    }
    
    public void safeIncrement() {
        if (lock.tryLock()) {  // Non-blocking attempt
            try {
                count++;
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("Could not acquire lock");
        }
    }
}

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private int count = 0;
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();
    
    public void write(int value) {
        rwLock.writeLock().lock();
        try {
            count = value;
        } finally {
            rwLock.writeLock().unlock();
        }
    }
    
    public int read() {
        rwLock.readLock().lock();
        try {
            return count;
        } finally {
            rwLock.readLock().unlock();
        }
    }
}

Thread Communication

wait(), notify(), and notifyAll()

public class ProducerConsumer {
    private List<Integer> queue = new LinkedList<>();
    private int capacity = 5;
    
    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (this) {
                while (queue.size() == capacity) {
                    wait();  // Wait if queue is full
                }
                
                System.out.println("Produced: " + value);
                queue.add(value++);
                notify();  // Notify consumer
                Thread.sleep(1000);
            }
        }
    }
    
    public void consume() throws InterruptedException {
        while (true) {
            synchronized (this) {
                while (queue.isEmpty()) {
                    wait();  // Wait if queue is empty
                }
                
                int value = queue.remove(0);
                System.out.println("Consumed: " + value);
                notify();  // Notify producer
                Thread.sleep(1000);
            }
        }
    }
}

Executor Framework

Thread Pools

Creating threads is expensive. Use thread pools to reuse threads and improve performance.

import java.util.concurrent.*;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        // Create a pool with 3 threads
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        // Submit tasks
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + 
                    " executed by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        
        executor.shutdown();
    }
}

Callable and Future

import java.util.concurrent.*;

public class CallableExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        // Callable returns a result
        Callable<Integer> task = () -> {
            Thread.sleep(2000);
            return 42;
        };
        
        // Submit callable and get Future
        Future<Integer> future = executor.submit(task);
        
        System.out.println("Task submitted");
        
        // Do other work...
        
        // Get result (blocks if not ready)
        Integer result = future.get();
        System.out.println("Result: " + result);
        
        executor.shutdown();
    }
}

Concurrent Collections

ConcurrentHashMap
BlockingQueue
CopyOnWriteArrayList

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// Thread-safe operations
map.put("key1", 1);
map.putIfAbsent("key2", 2);
map.computeIfAbsent("key3", k -> 3);

// Atomic operations
map.compute("key1", (k, v) -> v == null ? 1 : v + 1);

import java.util.concurrent.*;

// Producer-Consumer pattern
BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

// Producer
new Thread(() -> {
    try {
        for (int i = 0; i < 20; i++) {
            queue.put(i);  // Blocks if full
            System.out.println("Produced: " + i);
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

// Consumer
new Thread(() -> {
    try {
        while (true) {
            Integer item = queue.take();  // Blocks if empty
            System.out.println("Consumed: " + item);
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

import java.util.concurrent.CopyOnWriteArrayList;

// Thread-safe list optimized for reads
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

list.add("Item 1");
list.add("Item 2");

// Safe iteration even during modification
for (String item : list) {
    System.out.println(item);
}

Atomic Classes

import java.util.concurrent.atomic.*;

public class AtomicExample {
    private AtomicInteger counter = new AtomicInteger(0);
    private AtomicReference<String> atomicRef = new AtomicReference<>("initial");
    
    public void increment() {
        counter.incrementAndGet();  // Atomic increment
    }
    
    public void compareAndSet() {
        atomicRef.compareAndSet("initial", "updated");
    }
    
    public int addAndGet(int delta) {
        return counter.addAndGet(delta);
    }
}

Common Concurrency Patterns

Producer-Consumer with BlockingQueue

import java.util.concurrent.*;

public class ProducerConsumerPattern {
    private static BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);
    
    static class Producer implements Runnable {
        public void run() {
            try {
                for (int i = 0; i < 100; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    static class Consumer implements Runnable {
        public void run() {
            try {
                while (true) {
                    Integer item = queue.take();
                    System.out.println("Consumed: " + item);
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    public static void main(String[] args) {
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
    }
}

Thread-Safe Singleton

public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    
    private EagerSingleton() {}
    
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

Best Practices

Avoid Shared Mutable State

Use immutable objects when possible
Minimize shared state between threads
Use thread-local variables for thread-specific data

Use High-Level Concurrency Utilities

Prefer ExecutorService over manual thread creation
Use concurrent collections over synchronized collections
Leverage atomic classes for simple operations

Handle InterruptedException Properly

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // Restore interrupt status
    Thread.currentThread().interrupt();
    // Handle or propagate
}

Avoid Deadlocks

Always acquire locks in the same order
Use timeouts with tryLock()
Keep synchronized blocks small

Document Thread Safety

Clearly document thread-safety guarantees
Use annotations: @ThreadSafe, @NotThreadSafe

Common Pitfalls

Avoid these common concurrency mistakes:

Forgetting to Synchronize

// WRONG: Not thread-safe
private int count = 0;
public void increment() {
    count++;  // Race condition!
}

// CORRECT: Synchronized
private int count = 0;
public synchronized void increment() {
    count++;
}

Deadlock

// WRONG: Potential deadlock
synchronized (lock1) {
    synchronized (lock2) {
        // Critical section
    }
}
// Another thread:
synchronized (lock2) {
    synchronized (lock1) {  // Deadlock!
        // Critical section
    }
}

Not Using volatile for Flags

// WRONG: May not work correctly
private boolean running = true;

// CORRECT: Use volatile
private volatile boolean running = true;

Java Fundamentals

Learn Java basics

JVM Internals

Understand JVM architecture

Spring Framework

Enterprise development

Java & Spring

Databases

Algorithms & Data Structures

System Design

Java Multithreading & Concurrency

Java Multithreading & Concurrency

Understanding Threads

What is a Thread?

Thread Lifecycle

Creating Threads

Method 1: Extending Thread Class

Method 2: Implementing Runnable Interface (Recommended)

Method 3: Using Lambda Expressions (Java 8+)

Thread Synchronization

The Problem: Race Conditions

Solution 1: Synchronized Methods

Solution 2: Synchronized Blocks

Solution 3: Locks (java.util.concurrent.locks)

Thread Communication

wait(), notify(), and notifyAll()

Executor Framework

Thread Pools

Callable and Future

Concurrent Collections

Atomic Classes

Common Concurrency Patterns

Producer-Consumer with BlockingQueue

Thread-Safe Singleton

Best Practices

Common Pitfalls

Java Fundamentals

JVM Internals

Spring Framework

Build docs developers (and LLMs) love

Java & Spring

Databases

Algorithms & Data Structures

System Design

​Java Multithreading & Concurrency

​Understanding Threads

​What is a Thread?

​Thread Lifecycle

​Creating Threads

​Method 1: Extending Thread Class

​Method 2: Implementing Runnable Interface (Recommended)

​Method 3: Using Lambda Expressions (Java 8+)

​Thread Synchronization

​The Problem: Race Conditions

​Solution 1: Synchronized Methods

​Solution 2: Synchronized Blocks

​Solution 3: Locks (java.util.concurrent.locks)

​Thread Communication

​wait(), notify(), and notifyAll()

​Executor Framework

​Thread Pools

​Callable and Future

​Concurrent Collections

​Atomic Classes

​Common Concurrency Patterns

​Producer-Consumer with BlockingQueue

​Thread-Safe Singleton

​Best Practices

​Common Pitfalls

​Related Topics

Java Fundamentals

JVM Internals

Spring Framework

Build docs developers (and LLMs) love

Java Multithreading & Concurrency

Understanding Threads

What is a Thread?

Thread Lifecycle

Creating Threads

Method 1: Extending Thread Class

Method 2: Implementing Runnable Interface (Recommended)

Method 3: Using Lambda Expressions (Java 8+)

Thread Synchronization

The Problem: Race Conditions

Solution 1: Synchronized Methods

Solution 2: Synchronized Blocks

Solution 3: Locks (java.util.concurrent.locks)

Thread Communication

wait(), notify(), and notifyAll()

Executor Framework

Thread Pools

Callable and Future

Concurrent Collections

Atomic Classes

Common Concurrency Patterns

Producer-Consumer with BlockingQueue

Thread-Safe Singleton

Best Practices

Common Pitfalls

Related Topics