Demystifying Threads: A Beginner’s Guide to Java Concurrency#

Benefits of Concurrency#

• Improved Responsiveness: GUI-based applications, for example, shouldn’t freeze when performing lengthy tasks. Threads help by delegating long-running tasks away from the main UI thread.
• Better Resource Utilization: Modern CPUs often have multiple cores. Concurrency allows you to harness this computational potential more effectively.
• Scalability: As user load increases, concurrent systems more easily adapt than their single-threaded counterparts.

Concurrency vs. Parallelism#

While concurrency allows multiple tasks to be in progress at the same time, parallelism is specifically about multiple tasks literally executing at the same time (often on different CPU cores). Java’s threading model supports both concepts, but keep in mind that concurrency is more general—it’s about structuring a program as multiple threads of control, regardless of whether those controls actually run simultaneously on separate cores.

JVM and OS Collaboration#

Each thread in Java is typically backed by an operating system thread. This means the JVM collaborates with the OS to schedule and manage the threads, handing off tasks such as:

1. Scheduling: Deciding which thread runs on which CPU core.
2. Context Switching: Temporarily suspending a thread and switching to another, while saving the state of the suspended thread.
3. Synchronization Primitives: The OS provides low-level locks and atomic instructions used by the JVM to implement higher-level constructs.

Memory Model#

In Java, the memory model defines how variables are read from and written to memory in a multi-threaded environment. The most critical takeaway: without proper synchronization, you cannot guarantee visibility or ordering of variable updates across threads. For instance, even if one thread updates a shared variable, another thread might not immediately see that update.

The Thread Class#

The simplest way to create a thread is by extending the Thread class and overriding its run() method. However, this approach is often considered less flexible than using the Runnable or Callable interfaces.

1
public class MyThread extends Thread {
2
    @Override
3
    public void run() {
4
        System.out.println("I am running on thread: " + Thread.currentThread().getName());
5
    }
6

7
    public static void main(String[] args) {
8
        MyThread t = new MyThread();
9
        t.start(); // start() schedules the thread to run
10
    }
11
}

Implementing Runnable#

Most developers prefer implementing the Runnable interface, as it separates task logic from the thread creation mechanism. It also allows you to reuse the same Runnable across multiple threads.

1
public class MyRunnable implements Runnable {
2
    @Override
3
    public void run() {
4
        System.out.println("Thread task executed in: " + Thread.currentThread().getName());
5
    }
6

7
    public static void main(String[] args) {
8
        Thread thread = new Thread(new MyRunnable());
9
        thread.start();
10
    }
11
}

Callable and Future#

If you need a result from your thread’s execution, use Callable<V> instead of Runnable. Callable returns a value of type V and can throw checked exceptions. To retrieve the result, you typically use a Future<V>.

1
import java.util.concurrent.Callable;
2
import java.util.concurrent.ExecutionException;
3
import java.util.concurrent.FutureTask;
4

5
public class MyCallable implements Callable<Integer> {
6
    @Override
7
    public Integer call() throws Exception {
8
        // Some computation
9
        return 42;
10
    }
11

12
    public static void main(String[] args) throws InterruptedException, ExecutionException {
13
        MyCallable callableTask = new MyCallable();
14
        FutureTask<Integer> futureTask = new FutureTask<>(callableTask);
15
        Thread t = new Thread(futureTask);
16
        t.start();
17

18
        // Blocks until the task is done, then retrieves the result
19
        Integer result = futureTask.get();
20
        System.out.println("Result: " + result);
21
    }
22
}

Key Methods Affecting Thread States#

• start(): Moves the thread from NEW to RUNNABLE.
• sleep(): Moves the thread to TIMED_WAITING for a specified duration.
• wait(): Moves the thread to WAITING until it’s notified.
• join(): The calling thread goes into TIMED_WAITING or WAITING for the targeted thread to finish.

Understanding these states is crucial for debugging multi-threaded applications and for efficiently coordinating tasks among threads.

Immutable Objects#

One of the simplest ways to ensure thread safety is to use immutable objects. If no thread can modify the object’s state, then no synchronization mechanism is needed. Java has a variety of immutable classes like String, and you can create your own immutable classes by:

1. Declaring all fields as private and final.
2. Initializing all fields within the constructor.
3. Not providing any setter methods or other ways to modify internal state.

Stateless Classes#

For certain computation or utility classes, you can eliminate shared state altogether. Methods that rely exclusively on parameters and local variables in the method aren’t subject to concurrency issues (unless they reference or modify global data). Such classes are inherently thread-safe because they maintain no mutable internal state.

synchronized Keyword#

synchronized can be applied to methods or blocks. It guarantees:

1. Mutual Exclusion: No two threads can access a synchronized block on the same object simultaneously.
2. Visibility: Actions within a synchronized block are visible to subsequent threads that enter synchronized blocks guarded by the same lock.

1
public class Counter {
2
    private int count = 0;
3

4
    public synchronized void increment() {
5
        count++;
6
    }
7

8
    public synchronized int getValue() {
9
        return count;
10
    }
11
}

In the above example, the Counter class is thread-safe because increment() and getValue() cannot be invoked concurrently by more than one thread on the same Counter instance. However, note that synchronized imposes performance overhead due to lock acquisition and release.

Reentrant Locks#

The ReentrantLock class in java.util.concurrent.locks offers more sophisticated locking features than the built-in synchronized lock, such as:

• Trylock: Attempt to acquire lock without blocking indefinitely.
• Interruptible Lock Acquisition: Stop trying to acquire a lock if a thread is interrupted.
• Condition Variables: More advanced thread coordination than wait()/notify().

1
import java.util.concurrent.locks.Lock;
2
import java.util.concurrent.locks.ReentrantLock;
3

4
public class ReentrantLockExample {
5
    private final Lock lock = new ReentrantLock();
6
    private int count = 0;
7

8
    public void increment() {
9
        lock.lock();
10
        try {
11
            count++;
12
        } finally {
13
            lock.unlock();
14
        }
15
    }
16

17
    public int getValue() {
18
        lock.lock();
19
        try {
20
            return count;
21
        } finally {
22
            lock.unlock();
23
        }
24
    }
25
}

CountDownLatch#

CountDownLatch lets one or more threads wait until a set of operations being performed by other threads completes. It’s a simple integer counter that, when it reaches zero, releases all waiting threads.

1
import java.util.concurrent.CountDownLatch;
2

3
public class CountDownLatchExample {
4
    public static void main(String[] args) throws InterruptedException {
5
        int numTasks = 3;
6
        CountDownLatch latch = new CountDownLatch(numTasks);
7

8
        for (int i = 0; i < numTasks; i++) {
9
            new Thread(() -> {
10
                try {
11
                    // Simulate work
12
                    Thread.sleep(1000);
13
                } catch (InterruptedException e) {
14
                    Thread.currentThread().interrupt();
15
                }
16
                latch.countDown();
17
            }).start();
18
        }
19

20
        latch.await(); // Main thread waits until latch is zero
21
        System.out.println("All tasks finished!");
22
    }
23
}

CyclicBarrier#

While CountDownLatch can only be used once, CyclicBarrier is reusable. A CyclicBarrier makes threads wait for each other at a common checkpoint. Once the last thread arrives, all threads are released, and the barrier is reset for potential reuse.

Semaphore#

Semaphore controls the number of permits. Threads acquire permits before proceeding and release them afterward. It can be used to limit concurrent access to resources like database connections.

Exchanger#

Exchanger is a synchronization point at which two threads can swap objects. Each thread arrives with an object, and when both have arrived, the objects are exchanged.

Thread Pools#

A thread pool is a group of pre-instantiated threads that are reused to execute tasks. This approach improves performance by avoiding the overhead of thread creation for each task.

ExecutorService#

ExecutorService is the primary interface for assigning tasks to a thread pool. You can obtain different types of ExecutorService instances via the Executors factory class:

• Fixed Thread Pool: A pool with a fixed number of threads.
• Cached Thread Pool: A pool that expands as needed but reuses idle threads.
• Scheduled Thread Pool: For scheduling tasks with delays or periodic executions.

1
import java.util.concurrent.ExecutorService;
2
import java.util.concurrent.Executors;
3

4
public class ExecutorExample {
5
    public static void main(String[] args) {
6
        ExecutorService executor = Executors.newFixedThreadPool(3);
7

8
        for(int i = 0; i < 10; i++){
9
            final int taskID = i;
10
            executor.submit(() -> {
11
                System.out.println("Executing task " + taskID + " on " + Thread.currentThread().getName());
12
            });
13
        }
14

15
        executor.shutdown();
16
    }
17
}

Handling Task Results#

For tasks that return results, the ExecutorService provides the method submit(Callable<V> task). This method returns a Future<V> which you can query for completion and retrieve the result.

Parallel Streams#

If you have a list or collection of items to process, calling .parallelStream() can simplify concurrency:

1
import java.util.Arrays;
2
import java.util.List;
3

4
public class ParallelStreamExample {
5
    public static void main(String[] args) {
6
        List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8);
7

8
        int sum = numbers.parallelStream()
9
                         .mapToInt(Integer::intValue)
10
                         .sum();
11

12
        System.out.println("Sum: " + sum);
13
    }
14
}

While parallel streams are convenient, always measure performance. Sometimes parallelizing a task is slower if the data set is small or if the overhead of concurrency outweighs the computation.

Fork/Join Framework#

The Fork/Join framework, introduced in Java 7, is designed for tasks that can be recursively split into smaller chunks (“fork”), and then combined to form a result (“join”). It’s especially effective for divide-and-conquer algorithms.

1
import java.util.concurrent.RecursiveTask;
2

3
public class ForkJoinSum extends RecursiveTask<Long> {
4
    private final int[] array;
5
    private final int start;
6
    private final int end;
7
    private static final int THRESHOLD = 10_000;
8

9
    public ForkJoinSum(int[] array, int start, int end) {
10
        this.array = array;
11
        this.start = start;
12
        this.end = end;
13
    }
14

15
    @Override
16
    protected Long compute() {
17
        int length = end - start;
18
        if(length < THRESHOLD) {
19
            long sum = 0;
20
            for(int i = start; i < end; i++){
21
                sum += array[i];
22
            }
23
            return sum;
24
        } else {
25
            int mid = start + length / 2;
26
            ForkJoinSum left = new ForkJoinSum(array, start, mid);
27
            ForkJoinSum right = new ForkJoinSum(array, mid, end);
28
            left.fork();
29
            long rightResult = right.compute();
30
            long leftResult = left.join();
31
            return leftResult + rightResult;
32
        }
33
    }
34
}

You would submit this task to a ForkJoinPool. The framework handles splitting the task, executing sub-tasks in parallel, and merging results.

Race Conditions#

A race condition occurs when multiple threads access and modify shared data concurrently, without synchronization. The outcome depends on the relative timing of thread execution, often leading to unpredictable or erroneous results. To avoid race conditions:

• Use synchronized or locks when accessing shared mutable data.
• Consider making data immutable or using thread-safe data structures (e.g., ConcurrentHashMap).

Deadlocks#

A deadlock happens when two or more threads are waiting for each other’s locks, resulting in a permanent standstill. To avoid deadlocks:

• Always acquire locks in a consistent order.
• Use timeouts or tryLock mechanisms to detect or recover from lock acquisition failures.
• Keep synchronized sections small and avoid nested locks if possible.

Livelocks and Starvation#

• Livelock: Threads actively respond to each other but never make progress (imagine two people stepping aside repeatedly to let the other pass).
• Starvation: A thread is continuously denied access to resources (e.g., locks) because other threads receive priority.

Minimize these issues by designing fair locking strategies, using concurrency utilities that provide fairness (e.g., ReentrantLock with fairness parameters), and ensuring that your system is balanced in load distribution.

Overhead and Context Switching#

Excessive thread creation and context switching can degrade performance. Properly use thread pools, ensuring that the number of threads is tuned to match your hardware and task characteristics.