Java Multithreading

Multithreading enables concurrent execution of multiple threads in Java, allowing programs to perform multiple operations simultaneously.

What is a Thread?

A thread is the smallest unit of execution within a process. Java programs can have multiple threads running concurrently.

Creating Threads

Method 1: Extending Thread Class

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}

// Usage
MyThread thread = new MyThread();
thread.start();

Method 2: Implementing Runnable Interface (Preferred)

class MyTask implements Runnable {
    public void run() {
        System.out.println("Task executing: " + Thread.currentThread().getName());
    }
}

// Usage
Thread thread = new Thread(new MyTask());
thread.start();

Method 3: Using Lambda Expressions

Thread thread = new Thread(() -> {
    System.out.println("Lambda thread: " + Thread.currentThread().getName());
});
thread.start();

Thread Lifecycle

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

Thread thread = new Thread(() -> {
    try {
        Thread.sleep(1000);  // TIMED_WAITING
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

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

Synchronization

The Problem: Race Conditions

class Counter {
    private int count = 0;
    
    public void increment() {
        count++;  // Not thread-safe!
    }
    
    public int getCount() {
        return count;
    }
}

Solution: Synchronized Methods

class ThreadSafeCounter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;  // Thread-safe
    }
    
    public synchronized int getCount() {
        return count;
    }
}

Synchronized Blocks

class BankAccount {
    private double balance;
    
    public void withdraw(double amount) {
        synchronized(this) {  // Lock on this object
            if (balance >= amount) {
                balance -= amount;
            }
        }
    }
}

Thread Communication

wait() and notify()

class ProducerConsumer {
    private Queue<Integer> queue = new LinkedList<>();
    private int capacity = 5;
    
    public void produce(int item) throws InterruptedException {
        synchronized(this) {
            while (queue.size() == capacity) {
                wait();  // Wait for consumer
            }
            queue.add(item);
            notify();  // Notify consumer
        }
    }
    
    public int consume() throws InterruptedException {
        synchronized(this) {
            while (queue.isEmpty()) {
                wait();  // Wait for producer
            }
            int item = queue.remove();
            notify();  // Notify producer
            return item;
        }
    }
}

Concurrency Utilities

ExecutorService

ExecutorService executor = Executors.newFixedThreadPool(5);

executor.submit(() -> {
    System.out.println("Task 1");
});

executor.submit(() -> {
    System.out.println("Task 2");
});

executor.shutdown();  // Important: shutdown the executor

Future and Callable

ExecutorService executor = Executors.newSingleThreadExecutor();

Future<Integer> future = executor.submit(() -> {
    Thread.sleep(1000);
    return 42;
});

// Do other work while task runs
System.out.println("Doing other work...");

// Get result (blocks if not ready)
Integer result = future.get();
System.out.println("Result: " + result);

executor.shutdown();

Thread Pools

Fixed Thread Pool

ExecutorService executor = Executors.newFixedThreadPool(4);
// Always 4 threads available

Cached Thread Pool

ExecutorService executor = Executors.newCachedThreadPool();
// Creates threads as needed, reuses idle threads

Single Thread Executor

ExecutorService executor = Executors.newSingleThreadExecutor();
// Only one thread at a time

Common Issues

Deadlocks

// Avoid this pattern!
public void method1() {
    synchronized(lock1) {
        synchronized(lock2) {
            // Do work
        }
    }
}

public void method2() {
    synchronized(lock2) {
        synchronized(lock1) {
            // Do work
        }
    }
}

Starvation

Low-priority threads may never get CPU time.

Livelock

Threads keep responding to each other but make no progress.

Best Practices

Use ExecutorService instead of creating threads directly
Prefer immutable objects when possible
Use concurrent collections (ConcurrentHashMap, CopyOnWriteArrayList)
Minimize synchronized scope
Always shutdown ExecutorService
Handle InterruptedException properly
Use volatile for variables accessed by multiple threads

Modern Java Concurrency

Java 8+ introduced many improvements:

CompletableFuture for asynchronous programming
Parallel streams for data processing
Improved atomic classes
Lock interface for flexible locking

Multithreading is essential for building responsive and scalable Java applications, especially in modern multi-core systems.