The Necessity of Concurrent Programming

Concurrency is essential in modern software development for three primary reasons: improving response times for users, enabling modular and asynchronous code design, and maximizing hardware utilization by ensuring the CPU remains active.

Core Concepts

Processes vs. Threads

A process is the smallest unit of resource allocation in an operating system. When a program is executed, instructions and data are loaded into memory and CPU registers. The OS manages memory, file handles, and I/O resources for the process.

A thread is the smallest unit of CPU scheduling. It exists within a process and shares that process's resources (heap memory, file descriptors) while maintaining its own private elements, such as the program counter, stack, and local variables. Threads allow multiple execution paths to coexist within a single process.

Inter-Process Communication (IPC): Processes communicate via mechanisms like pipes (anonymous or named), signals, message queues, shared memory, semaphores, and sockets. Sockets are particularly versatile, enabling communication across different machines over a network.

CPU Cores and Threads

The relationship between CPU cores and threads is integral to parallelism. A single CPU core can execute one instruction stream at a time. While an 8-core CPU can run 8 threads simultaneously, technologies like Intel's Hyper-Threading allow a 1:2 core-to-thread ratio. In Java, Runtime.getRuntime().availableProcessors() returns the number of logical processors available.

Context Switching

When the OS switches the CPU from one thread to another, a context switch occurs. This involves:

1. Saving the current thread's state (program counter, registers) to memory.
2. Restoring the state of the next thread to run.
3. Jumping to the saved program counter location.

This operation is computationally expensive, potentially requiring thousands of CPU clock cycles, making efficient thread management critical for performance.

Concurrency vs. Parallelism

• Concurrency: Multiple tasks make progress during overlapping time periods (e.g., time-slicing on a single core).
• Parallelism: Multiple tasks execute simultaneously on multiple processing units.

Thread Lifecycle in Java

Java threads transition through six specific states:

1. NEW: Created but not yet started.
2. RUNNABLE: Executing in the JVM (combines 'ready' and 'running' states).
3. BLOCKED: Waiting for a monitor lock to enter a synchronized block.
4. WAITING: Waiting indefinitely for another thread to perform an action.
5. TIMED_WAITING: Waiting for a specified duration (e.g., sleep).
6. TERMINATED: Execution has finished.

Thread Creation and Management

Creating Threads

There are two primary approaches to creating threads in Java:

1. Extending the Thread Class:

public class CustomThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running via class extension.");
    }
}

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

2. Implementing the Runnable Interface:

public class TaskRunner implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running via Runnable.");
    }
}

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

The Runnable approach is generally preferred as it separates the task logic from the thread mechanism and allows the class to inherit from other types.

Handling Return Values: Callable and Future

Since Runnable#run() returns void, Java provides the Callable interface for tasks that must return a result. FutureTask wraps a Callable, allowing it to be executed by a Thread while providing a Future handle to retrieve the result.

Callable<Integer> calculation = () -> 42;
FutureTask<Integer> futureTask = new FutureTask<>(calculation);
new Thread(futureTask).start();
Integer result = futureTask.get(); // Blocks until result is ready

Thread Termination

The deprecated stop() method is unsafe as it releases locks immediately, potentially leaving data in an inconsistent state. The standard way to stop a thread is using interruption.

• interrupt(): Sets the thread's interruption status.
• isInterrupted(): Checks if the current thread has been interrupted.

If a thread is blocked (e.g., in sleep or wait), an interrupt() call will cause it to wake up and throw an InterruptedException, clearing the interruption flag in the process.

Threads vs. Coroutines (Virtual Threads)

Traditional Java threads map 1:1 to operating system kernel threads (Platform Threads). While robust, this model limits scalability due to the overhead of context switching and stack memory consumption.

Virtual Threads (Project Loom): Introduced in recent JDK versions, virtual threads are lightweight user-mode threads managed by the JVM. They dramatically reduce the memory footprint and allow applications to handle millions of concurrent connections efficiently, contrasting with the limited capacity of traditional thread pools.

Synchronization Mechanisms

The synchronized Keyword

Java uses intrinsic locks (monitors) to enforce mutual exclusion. The synchronized keyword ensures that only one thread can execute a specific block or method at a time.

• Object Lock: Locks on the specific instance.
• Class Lock: Locks on the Class object (static synchronized methods), affecting all instances.

Volatile

The volatile keyword ensures visibility: when one thread writes to a volatile variable, the new value is immediately visible to other threads. However, it does not guarantee atomicity for compound operations.

Wait/Notify Mechanism

Threads communicate coordination via the wait(), notify(), and notifyAll() methods. These must be called within a block synchronized on the same monitor object.

• wait(): Releases the lock and waits for notification.
• notify() / notifyAll(): Wakes up waiting threads to contend for the lock.

Standard pattern for waiting:

synchronized(lock) {
    while (!condition) {
        lock.wait();
    }
    // Proceed with logic
}

Piped I/O for Inter-Thread Communication

PipedInputStream and PipedOutputStream allow data transfer between threads via memory buffers, bypassing the need for intermediate disk storage.

PipedWriter writer = new PipedWriter();
PipedReader reader = new PipedReader();
writer.connect(reader); // Link the pipe ends

Thread consumer = new Thread(() -> {
    try {
        int data;
        while ((data = reader.read()) != -1) {
            System.out.print((char) data);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
});
consumer.start();

// Main thread acts as producer
writer.write("Data stream through pipe".toCharArray());
writer.close();

Asynchronous Programming with CompletableFuture

The traditional Future interface lacks support for callbacks and non-blocking composition. CompletableFuture, introduced in Java 8, resolves this by allowing chaining of asynchronous tasks and explicit handling of results or errors without blocking the main thread.