Java Thread Basics and Execution Life Cycle

A thread in Java is the smallest unit of execution within a program. Every Java application starts with a single thread, known as the main thread, which is initiated by the Java Virtual Machine (JVM) at the start of program execution. The main thread begins by invoking the main() method, from which the program’s operations commence.

In Java, a thread represents a separate path of execution. Java programs can utilize multiple threads to execute tasks concurrently, allowing for more efficient use of system resources. Each thread can operate independently while sharing the same memory space, which facilitates efficient communication and data sharing between threads. Threads are scheduled based on priority, and higher-priority threads are generally executed before lower-priority ones.

Threads in Java are essential for managing multiple tasks within the same program, such as performing computations while maintaining a responsive user interface or handling multiple client requests in server-side applications. Each thread maintains its own program counter, stack, and local variables, which enables it to execute independently of other threads.

Java threads enable concurrent execution, which is particularly beneficial for tasks like input/output operations, network communications, and other time-consuming processes. Understanding how to create and manage threads effectively is crucial for building responsive and efficient Java applications.

Creating a Thread in Java

Extending the Thread Class

One way to create a thread in Java is by extending the java.lang.Thread class. This involves defining a new class that inherits from Thread and overriding the run() method to specify the actions the thread should perform.

Example:

class MyThread extends Thread {

public void run() {

System.out.println(«Thread is running»);

}

public static void main(String[] args) {

MyThread t1 = new MyThread();

t1.start();

}

In this example, the start() method is used to create and launch a new thread, which then executes the code defined in the run() method.

Implementing the Runnable Interface

Another way to create a thread in Java is by implementing the Runnable interface. This approach involves creating a class that implements Runnable and defining the run() method. This method is then passed to a Thread object, which starts the thread.

Example:

class MyRunnable implements Runnable {

public void run() {

System.out.println(«Thread is running using Runnable»);

}

public static void main(String[] args) {

MyRunnable myRunnable = new MyRunnable();

Thread t1 = new Thread(myRunnable);

t1.start();

}

Using the Runnable interface is considered more flexible since the class can extend another class as well, unlike extending the Thread class, which limits inheritance.

Lifecycle of a Thread in Java

The lifecycle of a thread in Java represents the various states a thread can be in from creation to termination. These states are managed internally by the JVM and controlled via thread methods and scheduling mechanisms.

New State

When a thread object is instantiated using the Thread class, it is said to be in the New state. At this point, the thread has been created but has not yet started executing. The start() method has not been called.

Runnable State

Once the start() method is invoked on a thread object, the thread enters the Runnable state. It is now ready to run and is waiting for CPU time to be allocated by the thread scheduler. The thread is in a queue, prepared to execute as soon as it gets access to the CPU.

Running State

A thread transitions to the Running state when it is selected by the thread scheduler from the Runnable queue. In this state, the thread is actively executing the instructions defined in its run() method. The thread will remain in this state until it completes its execution or is moved to a non-runnable state.

Blocked (Non-Runnable) State

A thread enters the Blocked or Non-Runnable state when it is alive but not eligible to run. This can happen when the thread is waiting for a monitor lock or when the sleep() or wait() methods are called. Although the thread is still active, it cannot be scheduled for execution.

Dead State

A thread reaches the Dead state when it finishes executing its run method or when it is explicitly terminated. Once a thread enters this state, it cannot be restarted.

Java Thread Priorities

Each thread in Java has a priority, which helps determine the order in which threads are scheduled for execution. The priority is an integer ranging from 1 (lowest) to 10 (highest), with 5 as the default priority. Threads with higher priorities are typically given preference by the scheduler.

Thread priorities can be set using the following constants:

Thread.MIN_PRIORITY (1)
Thread.NORM_PRIORITY (5)
Thread.MAX_PRIORITY (10)

Example:

class PriorityThread extends Thread {

public void run() {

System.out.println(«Running thread name: » + Thread.currentThread().getName());

System.out.println(«Running thread priority: » + Thread.currentThread().getPriority());

}

public static void main(String[] args) {

PriorityThread t1 = new PriorityThread();

PriorityThread t2 = new PriorityThread();

t1.setPriority(Thread.MIN_PRIORITY);

t2.setPriority(Thread.MAX_PRIORITY);

t1.start();

t2.start();

}

By adjusting thread priorities, developers can influence the order of thread execution, though exact behavior may depend on the JVM and underlying operating system.

Common Constructors in the Thread Class

The Thread class provides several constructors to create and initialize thread instances. These constructors allow developers to specify thread names, associate Runnable objects, or use default values.

Thread()

Creates a new thread instance with default values and no specific task to execute until the run() method is defined.

Thread(String name)

Creates a thread and assigns it the specified name.

Thread(Runnable target)

Creates a thread with a Runnable target, allowing the thread to execute the run() method of the provided target object.

Thread(Runnable target, String name)

Creates a thread with a Runnable target and assigns it the specified name, offering both task delegation and identification.

Advanced Thread Lifecycle Concepts

Transition Between States

A Java thread transitions between states based on method calls and scheduling. For example, when sleep() is called, the thread moves from Running to Blocked (Timed Waiting). When a resource becomes available or a condition is met, the thread transitions back to Runnable. Understanding these transitions is critical for effective thread management, especially when optimizing for performance or preventing concurrency issues.

Timed Waiting State

Timed Waiting is a subtype of the Blocked state where a thread is waiting for a specified period. This state occurs when methods like sleep(milliseconds), join(milliseconds), or wait(milliseconds) are used. After the defined time has elapsed, the thread returns to the Runnable state unless interrupted or explicitly resumed.

Waiting State

Unlike Timed Waiting, the Waiting state does not have a time limit. A thread remains in this state until another thread sends a signal to wake it. This is common with methods like wait() without a timeout, join(), or waiting on an object’s monitor without a specified delay.

Termination and Cleanup

Once a thread enters the Dead state, it cannot be restarted. Proper cleanup, such as closing I/O streams or releasing locks, is essential before a thread terminates. Finalizers and shutdown hooks can be used to ensure that resources are properly handled, though they should be used with caution due to their potential impact on performance and maintainability.

Thread States Illustrated with Code

java

CopyEdit

public class ThreadStateExample extends Thread {

public void run() {

System. out.println(«Thread running…»);

}

public static void main(String[] args) {

ThreadStateExample t1 = new ThreadStateExample();

System.out.println(«State after creation: » + t1.getState());

t1.start();

System.out.println(«State after start(): » + t1.getState());

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(«State after execution: » + t1.getState());

}

This example prints the state of the thread at different stages: after creation, after starting, and after completion. It illustrates how threads transition across their lifecycle.

Thread Methods Overview

start()

Initiates a new thread of execution. Once called, the thread moves from the New state to Runnable and is eligible for CPU allocation.

run()

Defines the code to execute in the thread. It should never be called directly for concurrent execution—instead, use start() to ensure the thread runs on a new call stack.

sleep(milliseconds)

Puts the current thread into a blocked state for a specific time, after which it moves to the Runnable state.

join()

Waits for a thread to die. If join() is called on a thread, the calling thread waits until the specified thread completes execution.

yield()

Causes the currently executing thread to pause and allow other threads of equal priority to execute. It doesn’t guarantee any thread will get CPU time, but suggests the scheduler.

isAlive()

Checks whether a thread is still running or has completed execution. Returns true if the thread has been started and hasn’t yet died.

Thread Naming and Identification

Each thread has a name, which can help with debugging or logging. By default, threads are named Thread-0, Thread-1, etc., but custom names can be assigned using constructors or the setName() method.

Example:

java

CopyEdit

Thread t1 = new Thread(«MyCustomThread»);

System.out.println(«Thread Name: » + t1.getName());

Java Thread Scheduler

The thread scheduler is part of the JVM, responsible for deciding which thread to run next. It follows a preemptive or time-sliced round-robin algorithm, depending on the underlying operating system. The scheduler considers thread priorities but does not strictly follow them, especially on systems that do not support priority-based scheduling.

Understanding the non-deterministic nature of the scheduler is important. Developers should avoid relying on specific thread execution orders and instead use synchronization or coordination mechanisms for predictable results.

Thread Synchronization in Java

When multiple threads access shared resources, synchronization is necessary to prevent data inconsistency and race conditions.

The Synchronized Keyword

Used to lock methods or code blocks so only one thread can execute them at a time. This helps prevent race conditions when multiple threads try to modify shared variables.

java

CopyEdit

public class Counter {

private int count = 0;

public synchronized void increment() {

count++;

}

public int getCount() {

return count;

}

Static Synchronization

When a static method is synchronized, the lock is associated with the class, not an object instance. This is useful when multiple threads access static variables.

java

CopyEdit

public static synchronized void staticMethod() {

// synchronized on the class

}

Synchronization Block

Rather than synchronizing an entire method, a block within a method can be synchronized on a specific object.

java

CopyEdit

public void update() {

synchronized(this) {

// synchronized block

}

This allows more control over what part of the code is locked, improving performance by reducing contention.

Intrinsic Locks and Monitors

Each object in Java has an intrinsic lock or monitor. When a thread enters a synchronized method or block, it acquires the lock associated with the object. Other threads attempting to enter synchronized code on the same object are blocked until the lock is released.

Improper use of synchronization can lead to deadlocks, performance bottlenecks, or thread starvation. It’s essential to design thread-safe components carefully and avoid holding locks longer than necessary.

Thread Communication: wait(), notify(), notifyAll()

Java provides inter-thread communication methods through the Object class, allowing threads to cooperate by sharing locks and coordinating their activities.

wait()

Causes the current thread to release the lock and wait until another thread invokes notify() or notifyAll() on the same object.

notify()

Wakes up a single waiting thread that is waiting on the object’s monitor.

notifyAll()

Wakes up all waiting threads on the object. The awakened threads compete for the monitor, and only one can proceed.

Example:

java

CopyEdit

synchronized(obj) {

while (conditionNotMet) {

obj.wait();

}

// proceed when the condition is met

}

This approach is common in producer-consumer problems, where one thread waits for data while another produces it.

The Volatile Keyword

The volatile keyword ensures visibility of changes to variables across threads. When a variable is declared volatile, it prevents threads from caching the value and forces them to read it from main memory.

java

CopyEdit

private volatile boolean running = true;

This is useful for simple flags or status indicators that are updated by one thread and read by others.

Atomic Variables

Java provides atomic classes such as AtomicInteger, AtomicBoolean, and AtomicReference in the java.util.concurrent.atomic package. These allow lock-free, thread-safe operations on single variables.

Example:

java

CopyEdit

AtomicInteger count = new AtomicInteger(0);

count.incrementAndGet();

Atomic classes use low-level concurrency primitives to offer better performance than synchronization in some cases.

Deadlocks in Java

What is a Deadlock?

A deadlock occurs when two or more threads are blocked forever, waiting for each other to release locks. This happens when each thread holds a lock that another thread needs, creating a circular dependency. Deadlocks can cause applications to freeze or become unresponsive.

Conditions for Deadlock

Deadlock requires four conditions to hold simultaneously:

Mutual Exclusion: At least one resource is held in a non-shareable mode.
Hold and Wait: Threads holding resources can request additional resources.
No Preemption: Resources cannot be forcibly taken from a thread.
Circular Wait: A cycle of threads exists where each thread waits for a resource held by the next thread.

Example of Deadlock

java

CopyEdit

public class DeadlockDemo {

private final Object resource1 = new Object();

private final Object resource2 = new Object();

public void method1() {

synchronized (resource1) {

System.out.println(«Thread 1: Locked resource 1»);

try { Thread.sleep(50); } catch (InterruptedException e) {}

synchronized (resource2) {

System.out.println(«Thread 1: Locked resource 2»);

}

public void method2() {

synchronized (resource2) {

System.out.println(«Thread 2: Locked resource 2»);

try { Thread.sleep(50); } catch (InterruptedException e) {}

synchronized (resource1) {

System.out.println(«Thread 2: Locked resource 1»);

}

public static void main(String[] args) {

DeadlockDemo demo = new DeadlockDemo();

Thread t1 = new Thread(demo::method1);

Thread t2 = new Thread(demo::method2);

t1.start();

t2.start();

}

Here, Thread 1 locks resource1 and waits for resource2, while Thread 2 locks resource2 and waits for resource1. This causes both threads to wait indefinitely.

Detecting Deadlocks

Thread Dumps: Use jstack or IDE thread dumps to identify deadlock cycles.
JVM Tools: Java Mission Control and VisualVM provide deadlock detection.
Logging: Adding log statements before acquiring locks helps trace deadlocks.

Preventing Deadlocks

Lock Ordering: Acquire locks in a consistent global order across all threads.
Timeouts: Use tryLock() with timeouts (from java.util.concurrent.locks.Lock).
Avoid Nested Locks: Minimize synchronized blocks or avoid acquiring multiple locks.
Use Concurrency Utilities: Replace manual locks with high-level abstractions.

Thread Pools and Executors

Managing threads efficiently is critical. Creating and destroying threads frequently is expensive, so Java provides thread pools to reuse threads.

What is a Thread Pool?

A thread pool maintains a pool of worker threads ready to execute tasks. Tasks are submitted to the pool, and available threads pick them up. This avoids the overhead of creating new threads repeatedly.

The Executor Framework

Java’s java. Util. The concurrent package includes the Executor framework, which simplifies thread pool usage.

Creating Thread Pools with Executors

java

CopyEdit

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ThreadPoolExample {

public static void main(String[] args) {

ExecutorService executor = Executors.newFixedThreadPool(3);

Runnable task = () -> {

System.out.println(Thread.currentThread().getName() + » is executing task»);

};

for (int i = 0; i < 10; i++) {

executor.submit(task);

}

executor.shutdown();

}

Types of Thread Pools

FixedThreadPool: Creates a fixed number of threads.
CachedThreadPool: Creates new threads as needed and reuses idle ones.
SingleThreadExecutor: Uses a single worker thread to execute tasks sequentially.
ScheduledThreadPool: Executes tasks after a delay or periodically.

Advantages of Using Thread Pools

Reuses existing threads, reducing overhead.
Controls the number of concurrent threads.
Offers built-in queue management.
Supports task scheduling.

Concurrency Utilities in Java. Util.concurrent

Beyond basic threading, Java provides powerful utilities to handle common concurrency problems.

CountDownLatch

A synchronization aid that allows one or more threads to wait until a set of operations completes.

java

CopyEdit

import java.util.concurrent.CountDownLatch;

public class LatchExample {

public static void main(String[] args) throws InterruptedException {

CountDownLatch latch = new CountDownLatch(3);

Runnable task = () -> {

System.out.println(Thread.currentThread().getName() + » finished work»);

latch.countDown();

};

new Thread(task).start();

latch.await(); // main thread waits

System.out.println(«All tasks completed»);

}

CyclicBarrier

Allows a group of threads to wait for each other at a barrier point.

java

CopyEdit

import java.util.concurrent.CyclicBarrier;

public class BarrierExample {

public static void main(String[] args) {

CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println(«All threads reached barrier»));

Runnable task = () -> {

System.out.println(Thread.currentThread().getName() + » working»);

try {

Thread.sleep(1000);

barrier.await();

} catch (Exception e) {

e.printStackTrace();

}

};

new Thread(task).start();

}

Semaphore

Controls access to a resource by multiple threads by maintaining a set number of permits.

java

CopyEdit

import java.util.concurrent.Semaphore;

public class SemaphoreExample {

private static final Semaphore semaphore = new Semaphore(2);

public static void main(String[] args) {

Runnable task = () -> {

try {

semaphore.acquire();

System.out.println(Thread.currentThread().getName() + » acquired permit»);

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

System.out.println(Thread.currentThread().getName() + » released permit»);

semaphore.release();

}

};

for (int i = 0; i < 5; i++) {

new Thread(task).start();

}

Futures and Callables

Java’s Callable interface allows tasks to return results and throw exceptions, unlike Runnable. Coupled with Future, it provides a way to retrieve task results asynchronously.

Using Callable and Future

java

CopyEdit

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class CallableExample {

public static void main(String[] args) throws ExecutionException, InterruptedException {

ExecutorService executor = Executors.newSingleThreadExecutor();

Callable<String> callableTask = () -> {

Thread.sleep(1000);

return «Task completed»;

};

Future<String> future = executor.submit(callableTask);

System.out.println(«Waiting for result…»);

String result = future.get(); // blocks until result available

System.out.println(«Result: » + result);

executor.shutdown();

}

Best Practices for Java Multithreading

1. Minimize Synchronization Scope

Only synchronize critical sections that access shared mutable data to reduce contention and improve performance.

2. Prefer High-Level Concurrency Utilities

Use Java. Util. Concurrent package’s utilities, such as thread pools, locks, and synchronization aids, instead of low-level synchronized blocks or manual thread management.

3. Avoid Deadlocks

Use consistent lock ordering and minimize nested locks. Prefer lock timeouts and deadlock detection tools.

4. Use Immutable Objects

Immutable objects are naturally thread-safe because their state cannot change after creation, eliminating synchronization needs.

5. Avoid Thread Interruption Ignorance

Always handle InterruptedException properly by either restoring the interrupt status or exiting promptly.

6. Use Volatile for Flags

For simple flags or variables updated by one thread and read by others, use volatile to ensure visibility.

7. Prefer Executors over Manual Threads

Executors provide better thread lifecycle management and resource optimization compared to manually managing threads.

8. Document Threading Assumptions

Document any assumptions about thread safety, synchronization, and expected concurrency behaviors to ease maintenance and reduce bugs.

Thread Safety Concepts

Immutable Objects

Immutable classes cannot be modified after construction, making them inherently thread-safe.

Example:

java

CopyEdit

public final class ImmutablePerson {

private final String name;

public ImmutablePerson(String name) {

this.name = name;

}

public String getName() {

return name;

}

Thread-Safe Collections

Use classes from Java. Util. Concurrent such as ConcurrentHashMap, CopyOnWriteArrayList, or synchronized wrappers from Collections.synchronizedXXX() to safely use collections across threads.

Handling Exceptions in Threads

Exceptions thrown from threads are often ignored if not properly handled. Use these strategies:

Catch Exceptions Inside run() or call() Methods: Prevent thread termination.
Set UncaughtExceptionHandler: Catch unhandled exceptions.

Example:

java

CopyEdit

Thread t = new Thread(() -> {

throw new RuntimeException(«Exception in thread»);

});

t.setUncaughtExceptionHandler((thread, throwable) -> {

System.out.println(«Caught exception from » + thread.getName() + «: » + throwable.getMessage());

});

t.start();

Thread Local Variables

ThreadLocal provides thread-local variables, where each thread has its isolated copy. This helps avoid shared state issues without synchronization.

java

CopyEdit

ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 1);

System.out.println(threadLocal.get()); // prints 1

threadLocal.set(5);

Java Memory Model (JMM) Basics

Understanding the JMM is key to writing correct multithreaded programs. It defines how threads interact through memory and how changes to variables become visible across threads.

Happens-Before Relationship: Guarantees visibility and ordering of operations.
Synchronization: Provides happens-before guarantees.
Volatile Variables: Ensure visibility of changes.
Final Fields: Properly published immutable fields ensure safe access.

Advanced Synchronization Techniques

Reentrant Locks (java.util.concurrent.locks.ReentrantLock)

While synchronized blocks are simple and effective, ReentrantLock from the java.util.concurrent.The locks package offers more advanced locking capabilities.

Features of ReentrantLock

Explicit lock and unlock control.
Ability to attempt lock acquisition with timeout (tryLock).
Supports fairness policies to avoid thread starvation.
Provides condition variables for complex wait/notify scenarios.

Example Usage

java

CopyEdit

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {

private final ReentrantLock lock = new ReentrantLock();

public void performTask() {

lock.lock();

try {

System.out.println(Thread.currentThread().getName() + » acquired lock»);

// Critical section code

} finally {

lock.unlock();

System.out.println(Thread.currentThread().getName() + » released lock»);

}

public static void main(String[] args) {

ReentrantLockExample example = new ReentrantLockExample();

Runnable task = example::performTask;

Thread t1 = new Thread(task, «Thread-1»);

Thread t2 = new Thread(task, «Thread-2»);

t1.start();

t2.start();

}

Condition Variables

ReentrantLock supports Condition objects, which are more flexible than Object.wait() and Object.notify(). Conditions allow multiple wait-sets per lock.

Example of Condition Usage

java

CopyEdit

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class ConditionExample {

private final Lock lock = new ReentrantLock();

private final Condition condition = lock.newCondition();

private boolean ready = false;

public void awaitReady() throws InterruptedException {

lock.lock();

try {

while (!ready) {

condition.await();

}

System.out.println(Thread.currentThread().getName() + » is proceeding»);

} finally {

lock.unlock();

}

public void signalReady() {

lock.lock();

try {

ready = true;

condition.signalAll();

} finally {

lock.unlock();

}

public static void main(String[] args) throws InterruptedException {

ConditionExample example = new ConditionExample();

Thread waitingThread = new Thread(() -> {

try {

example.awaitReady();

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

}

}, «WaitingThread»);

waitingThread.start();

Thread.sleep(2000);

Thread signalingThread = new Thread(example::signalReady, «SignalingThread»);

signalingThread.start();

}

ReadWriteLock

For scenarios with many readers but few writers, ReadWriteLock allows multiple threads to read simultaneously while restricting write access.

java

CopyEdit

import java.util.concurrent.locks.ReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

private int value = 0;

public void write(int newValue) {

rwLock.writeLock().lock();

try {

value = newValue;

System.out.println(Thread.currentThread().getName() + » wrote value: » + newValue);

} finally {

rwLock.writeLock().unlock();

}

public int read() {

rwLock.readLock().lock();

try {

System.out.println(Thread.currentThread().getName() + » read value: » + value);

return value;

} finally {

rwLock.readLock().unlock();

}

public static void main(String[] args) {

ReadWriteLockExample example = new ReadWriteLockExample();

Runnable readTask = example::read;

Runnable writeTask = () -> example.write((int) (Math.random() * 100));

Thread writer = new Thread(writeTask, «WriterThread»);

Thread reader1 = new Thread(readTask, «ReaderThread-1»);

Thread reader2 = new Thread(readTask, «ReaderThread-2»);

reader1.start();

reader2.start();

writer.start();

}

Thread Communication: Wait, Notify, and NotifyAll

Threads often need to communicate, especially when coordinating access to shared resources.

Using wait() and notify()

wait() causes the current thread to release the lock and enter the waiting state.
Notify () wakes up one waiting thread.
notifyAll() wakes up all waiting threads.

Example: Producer-Consumer Using wait() and notify()

java

CopyEdit

import java.util.LinkedList;

import java.util.Queue;

public class ProducerConsumer {

private final Queue<Integer> queue = new LinkedList<>();

private final int LIMIT = 5;

public synchronized void produce() throws InterruptedException {

int value = 0;

while (true) {

while (queue.size() == LIMIT) {

wait();

}

queue.offer(value);

System.out.println(«Produced: » + value);

value++;

notify();

Thread.sleep(500);

}

public synchronized void consume() throws InterruptedException {

while (true) {

while (queue.isEmpty()) {

wait();

}

int value = queue.poll();

System.out.println(«Consumed: » + value);

notify();

Thread.sleep(500);

}

public static void main(String[] args) {

ProducerConsumer pc = new ProducerConsumer();

Thread producer = new Thread(() -> {

try {

pc.produce();

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

}

});

Thread consumer = new Thread(() -> {

try {

pc.consume();

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

}

});

producer.start();

consumer.start();

}

Concurrent Collections

Java provides thread-safe collections optimized for concurrent access.

ConcurrentHashMap

A hash table supporting full concurrency of retrievals and adjustable concurrency for updates.

Example

java

CopyEdit

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {

public static void main(String[] args) {

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

Runnable writer = () -> {

for (int i = 0; i < 5; i++) {

map.put(Thread.currentThread().getName() + «-» + i, i);

System.out.println(Thread.currentThread().getName() + » put: » + i);

try {

Thread.sleep(50);

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

}

};

Thread t1 = new Thread(writer, «Writer1»);

Thread t2 = new Thread(writer, «Writer2»);

t1.start();

t2.start();

}

Other Collections

CopyOnWriteArrayList for mostly-read lists.
BlockingQueue implementations (ArrayBlockingQueue, LinkedBlockingQueue) for producer-consumer.
ConcurrentSkipListMap for sorted maps.

Fork/Join Framework

Introduced in Java 7, the Fork/Join framework supports parallelism by recursively splitting tasks.

ForkJoinTask, RecursiveTask, and RecursiveAction

RecursiveTask: Returns a result.
RecursiveAction: No result (void).

Example: Computing Fibonacci Numbers

java

CopyEdit

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.RecursiveTask;

public class FibonacciTask extends RecursiveTask<Integer> {

private final int n;

public FibonacciTask(int n) {

this.n = n;

}

@Override

protected Integer compute() {

if (n <= 1) return n;

FibonacciTask f1 = new FibonacciTask(n — 1);

f1.fork(); // fork a new subtask

FibonacciTask f2 = new FibonacciTask(n — 2);

int result2 = f2.compute(); // compute directly

int result1 = f1.join(); // wait for result

return result1 + result2;

}

public static void main(String[] args) {

ForkJoinPool pool = new ForkJoinPool();

int n = 10;

int result = pool.invoke(new FibonacciTask(n));

System.out.println(«Fibonacci number » + n + » is » + result);

}

Reactive and Asynchronous Programming Basics

CompletableFuture

CompletableFuture supports async programming and chaining.

Example

java

CopyEdit

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {

public static void main(String[] args) {

CompletableFuture.supplyAsync(() -> {

System. out.println(«Running task…»);

return «Hello»;

}).thenApply(s -> s + » World»)

.thenAccept(System.out::println)

.join();

}

Performance Tuning and Monitoring

Tips for Optimizing Multithreaded Java Programs

Minimize locking and contention.
Use efficient concurrent collections.
Prefer thread pools to avoid thread creation overhead.
Avoid blocking operations where possible.
Profile thread usage and CPU time.
Use tools like VisualVM, Java Mission Control for monitoring.

Debugging and Testing Multithreaded Code

Techniques

Use thread dumps (jstack) to analyze stuck or deadlocked threads.
Log thread activity and synchronization points.
Use thread sanitizer tools or concurrency testing frameworks (e.g., IBM ConTest, JCStress).
Write unit tests using tools like JUnit with concurrency utilities.
Use deterministic scheduling tools to reproduce concurrency bugs.

Final Thoughts on Java Threading and Concurrency

Mastering threading and concurrency in Java is essential for developing high-performance, scalable, and responsive applications. The ability to run multiple tasks simultaneously can significantly improve application efficiency, especially in today’s multi-core and distributed computing environments.

Key Takeaways

Threads are powerful but complex: While threads can boost performance, improper use leads to subtle bugs like race conditions, deadlocks, and resource starvation. Understanding thread lifecycle, synchronization, and communication mechanisms is critical.
Use the right tools for the job: Java provides a rich set of concurrency utilities—from basic synchronized blocks to advanced constructs like ReentrantLock, ConcurrentHashMap, and the Fork/Join framework. Leveraging these tools correctly reduces boilerplate code and avoids common pitfalls.
Thread safety is paramount: Always ensure that shared data is accessed safely using synchronization or concurrent data structures. Immutable objects, thread confinement, and atomic variables are effective strategies to simplify thread safety.
Design with concurrency in mind: Multithreading should be considered early in design, especially for applications involving I/O, UI responsiveness, or complex task parallelism. Proper architectural decisions reduce the complexity of concurrent code later.
Testing and debugging are challenging but doable: Use dedicated testing frameworks and profiling tools to uncover concurrency issues. Log extensively and analyze thread dumps to diagnose problems like deadlocks or thread leaks.
Performance tuning requires profiling: Blind optimization can be counterproductive. Profile your application to identify bottlenecks, and apply targeted improvements such as reducing contention, tuning thread pools, or optimizing task granularity.
Stay up-to-date: Java’s concurrency landscape evolves with new frameworks and best practices. Explore reactive programming (CompletableFuture, Project Reactor), parallel streams, and emerging APIs to write modern concurrent code.

Concurrency programming is a challenging but rewarding skill that opens the door to creating sophisticated software able to fully utilize modern hardware capabilities. With careful design, thoughtful synchronization, and ongoing learning, you can harness Java’s threading features to build fast, efficient, and robust applications.

Java Thread Basics and Execution Life Cycle

Related posts: