Detailed Explanation of ThreadLocal in Java

I. Basic Concepts of ThreadLocal
ThreadLocal is a utility class in Java used to implement thread-local variables. It can create independent variable copies for each thread that uses the variable, achieving thread isolation and avoiding shared resource competition issues in multithreaded environments.

II. Core Principles of ThreadLocal

1. Data Structure Design

   • Each Thread internally maintains a ThreadLocalMap instance
   • ThreadLocalMap is a customized hash table where the key is a weak reference to the ThreadLocal object and the value is the stored data
   • This design enables each thread to have its own independent variable copy

2. Key Method Analysis

   public T get() {
       Thread t = Thread.currentThread();  // Get current thread
       ThreadLocalMap map = getMap(t);     // Get thread's ThreadLocalMap
       if (map != null) {
           ThreadLocalMap.Entry e = map.getEntry(this);  // Search using current ThreadLocal as key
           if (e != null) return (T)e.value;
       }
       return setInitialValue();  // Initialize value
   }
   

III. ThreadLocal Usage Example

public class ThreadLocalDemo {
    private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
    
    public static void main(String[] args) {
        // Thread 1 operation
        new Thread(() -> {
            threadLocal.set(100);
            System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
        }).start();
        
        // Thread 2 operation (unaffected by Thread 1)
        new Thread(() -> {
            threadLocal.set(200);
            System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
        }).start();
    }
}

IV. Memory Leak Issues and Solutions

1. Root Cause

   • ThreadLocalMap's key is a weak reference, while the value is a strong reference
   • When a ThreadLocal object is garbage collected, the key becomes null, but the value still has a strong reference chain
   • If threads run for a long time (e.g., threads in a thread pool), the value cannot be garbage collected

2. Preventive Measures

   • Explicitly clean up by calling the remove() method: threadLocal.remove();
   • Use try-finally to ensure cleanup:

   try {
       threadLocal.set(value);
       // Business logic
   } finally {
       threadLocal.remove();
   }
   

V. ThreadLocal Application Scenarios

1. Database Connection Management

   • Each thread maintains its own independent database connection
   • Avoid passing Connection parameters between methods

2. User Session Information

   • Store current logged-in user information in web development
   • Alternative to passing parameters through multiple layers

3. Date Formatting

   • SimpleDateFormat is not thread-safe
   • Provide independent instances for each thread through ThreadLocal

VI. Differences from InheritableThreadLocal

1. ThreadLocal: Data isolation between parent and child threads
2. InheritableThreadLocal: Child threads can inherit ThreadLocal variables from parent threads
3. Inheritance occurs during Thread object creation through the init() method, which completes data copying

VII. Best Practice Recommendations

1. Use private static to modify ThreadLocal variables whenever possible
2. In thread pool environments, the remove() method must be called for cleanup
3. Consider using the naming convention recommended by Alibaba's code specification: private static final ThreadLocal<T> CONTEXT = new ThreadLocal<>();
4. For scenarios requiring cross-thread data transfer, consider using TransmittableThreadLocal (open-source by Alibaba)