Understanding ThreadLocal: Solving Thread Safety Issues in Java

Introduction

Thread safety problems occur when multiple threads concurrently operate on the same shared variable without synchronization, leading to unexpected results. A classic example shows two operators accessing a bank account: one deposits 100, the other withdraws 50, but without locking the final balance becomes 950 instead of the expected 1050.

Adding a synchronization lock ensures that the operations are performed sequentially, producing the correct final balance.

ThreadLocal Issues

ThreadLocal is a JDK class that provides thread‑local variables. Each thread that accesses a ThreadLocal variable gets its own local copy, eliminating shared‑variable conflicts.

Many articles claim ThreadLocal solves concurrency problems, but it actually isolates data per thread rather than synchronizing shared resources.

Personal Thoughts

After reading "Java Concurrency in Practice", the author understands that ThreadLocal provides a copy of a variable for each thread, so the variable can only be accessed by the owning thread, which means it does not directly solve concurrency issues but avoids shared access.

How to Use

Example: two threads each set a random number in a ThreadLocal variable. The output shows different values for each thread, confirming isolation.

Output: Thread[Thread-1,5,main]====57 Thread[Thread-0,5,main]====75

If ThreadLocal were replaced by a shared collection, the second thread would overwrite the first thread's value, demonstrating why each thread must have its own copy.

Implementation Principle

ThreadLocal stores values in the thread's threadLocals map, where the key is the ThreadLocal instance and the value is the stored data.

threadLocals holds the values of ThreadLocal variables for the current thread.

If the map is null, a new ThreadLocalMap is created.

A flowchart illustrates the creation process.

set Method

The set method obtains the current thread, ensures a map exists, and stores the value.

getMap

returns the thread's threadLocals; if null, it creates a new ThreadLocalMap.

get Method

The get method retrieves the value for the current thread, initializing an empty entry if necessary.

remove Method

The remove method simply clears the entry from the map.

Summary

ThreadLocal works by storing values in each thread's threadLocals map; if a thread lives long, the values persist and may cause memory leaks, so they should be removed when no longer needed. ThreadLocal does not support inheritance; the child thread cannot see values set in the parent thread.

Output: Thread[Thread-0,5,main]====null

To inherit values, use InheritableThreadLocal, which replaces threadLocals with inheritableThreadLocals, allowing child threads to access parent values.

Thread initialization checks the parent thread's inheritableThreadLocals and copies them to the child thread via createInheritedMap.