Multithreading and Concurrency

55 min

Multithreading enables Java programs to execute multiple threads concurrently, improving performance for I/O-bound operations and enabling responsive user interfaces. Threads are lightweight processes that share memory space, allowing concurrent execution of code. Java's threading model enables you to take advantage of multi-core processors and handle multiple tasks simultaneously. Understanding multithreading is essential for building responsive, efficient Java applications.

Threads can be created by extending the `Thread` class or implementing the `Runnable` interface. The `Runnable` interface is preferred because it's more flexible (Java supports single inheritance). Threads are started with `start()`, which creates a new thread and calls `run()`. The `Thread` class provides methods for thread management: `sleep()`, `join()`, `interrupt()`, and more. Understanding thread creation helps you implement concurrent programs.

Synchronization prevents race conditions when multiple threads access shared data. The `synchronized` keyword creates synchronized blocks or methods that only one thread can execute at a time. `synchronized` ensures thread safety but can cause performance issues if overused. Java 5+ provides `java.util.concurrent` package with higher-level synchronization tools: `Lock`, `Semaphore`, `CountDownLatch`, and more. Understanding synchronization helps you write thread-safe code.

The Executor framework (Java 5+) provides a higher-level abstraction for managing thread pools. `ExecutorService` manages a pool of threads and executes tasks asynchronously. Thread pools reuse threads, reducing thread creation overhead. Common executors include `newFixedThreadPool()`, `newCachedThreadPool()`, and `newScheduledThreadPool()`. The framework handles thread lifecycle management automatically. Understanding the Executor framework helps you implement efficient concurrent programs.

Thread safety is crucial for concurrent programs. Shared data must be protected from concurrent access. Common issues include race conditions (unpredictable behavior from concurrent access), deadlocks (threads waiting for each other), and livelocks (threads actively trying to resolve deadlock). Solutions include synchronization, immutable objects, thread-local storage, and concurrent collections. Understanding thread safety helps you avoid common concurrency bugs.

Best practices include using the Executor framework instead of creating threads directly, using concurrent collections (`ConcurrentHashMap`, `CopyOnWriteArrayList`) when appropriate, minimizing shared mutable state, using immutable objects when possible, and understanding performance implications of synchronization. Concurrency should be used judiciously—not all programs benefit from multithreading. Understanding multithreading enables you to build responsive, efficient Java applications.

Key Concepts

Multithreading enables concurrent execution of multiple threads.
Threads can be created by extending Thread or implementing Runnable.
Synchronization prevents race conditions in concurrent access.
Executor framework provides thread pool management.
Thread safety is crucial for correct concurrent programs.

Learning Objectives

Master

Creating and managing threads in Java
Understanding synchronization and thread safety
Using the Executor framework for thread pool management
Avoiding common concurrency pitfalls

Develop

Concurrent programming thinking
Understanding thread safety and race conditions
Designing thread-safe, efficient concurrent applications

Tips

Use Executor framework instead of creating threads directly.
Use synchronized blocks/methods to protect shared data.
Prefer concurrent collections for thread-safe data structures.
Minimize shared mutable state to reduce synchronization needs.

Common Pitfalls

Not synchronizing shared data, causing race conditions.
Creating too many threads, causing performance degradation.
Deadlocks from circular wait conditions.
Not understanding thread safety, causing unpredictable bugs.

Summary

Multithreading enables concurrent execution of multiple threads.
Synchronization prevents race conditions in concurrent access.
Executor framework provides efficient thread pool management.
Thread safety is essential for correct concurrent programs.
Understanding multithreading enables responsive, efficient applications.

Exercise

Create a multithreaded program that demonstrates thread synchronization and communication.

import java.util.concurrent.*;

public class MultithreadingDemo {
    private static int counter = 0;
    private static final Object lock = new Object();
    
    static class IncrementTask implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                synchronized (lock) {
                    counter++;
                }
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        // Submit multiple tasks
        for (int i = 0; i < 4; i++) {
            executor.submit(new IncrementTask());
        }
        
        // Shutdown and wait for completion
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS);
        
        System.out.println("Final counter value: " + counter);
        
        // Demonstrate CompletableFuture
        CompletableFuture<String> future = CompletableFuture
            .supplyAsync(() -> "Hello")
            .thenApply(s -> s + " World")
            .thenApply(String::toUpperCase);
        
        System.out.println("Async result: " + future.get());
    }
}

Multithreading and Concurrency