ThreadLocal

Concurrency bugs stem from threads sharing mutable state. The ThreadLocal class bypasses synchronization by providing thread-confined variables, ensuring each thread maintains its own isolated copy of a variable.

Memory Leak Risk (Crucial)

ThreadLocal variables are stored inside a custom map (ThreadLocalMap) owned by each Thread object. The map keys are WeakReferences to the ThreadLocal instance, but the values are strong references.

If a thread is reused (such as in an application server thread pool) and the ThreadLocal value is not removed, the strong reference to the value remains active as long as the worker thread is alive. This causes major memory leaks.

Rule: Always call threadLocal.remove() inside a finally block when the request cycle completes.

Code Walkthrough

This class demonstrates using ThreadLocal to associate unique transaction IDs with different threads.

import java.util.UUID;
public class TransactionContext {
    private static final ThreadLocal transactionId = 
        ThreadLocal.withInitial(() -> UUID.randomUUID().toString());
public static String getTransactionId() {
        return transactionId.get();
    }
public static void clear() {
        transactionId.remove(); // Prevents memory leaks in thread pools!
    }
public static void executeBusinessLogic() {
        try {
            System.out.println("Processing: " + getTransactionId() + " on " + Thread.currentThread().getName());
        } finally {
            clear();
        }
    }
}

Interview-Relevant Information