Why can ThreadLocal achieve thread isolation?

about ThreadLocal We're all familiar , Its function is like its name —— To hold 「 Thread local 」 Variable .

First, feel it through a small example ：

private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();

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

    Thread threadOne = new Thread(()->{
        threadLocal.set("ThreadOne：" + Thread.currentThread().getName());
        log.info(" Threads  One  The local variable value is ：{}", threadLocal.get());
        threadLocal.remove();
        log.info(" Threads  One remove  The post local variable value is ：{}", threadLocal.get());
    });

    Thread threadTwo = new Thread(()->{
        threadLocal.set("ThreadTwo：" + Thread.currentThread().getName());
        log.info(" Threads  Two  The local variable value is ：{}", threadLocal.get());
    });

    threadOne.start();
    threadTwo.start();
}

Running results ：

 Threads  One  The local variable value is ：ThreadOne：Thread-0
 Threads  One remove  The post local variable value is ：null
 Threads  Two  The local variable value is ：ThreadTwo：Thread-1
OK, In terms of effect ,ThreadLocal  It is indeed thread isolated , that , How does it achieve thread isolation ？ Now let's dig up the source code , See how it does it ：

public void set(T value) {
   Thread t = Thread.currentThread();
   ThreadLocalMap map = getMap(t);
   if (map != null)
       map.set(this, value);
   else
       createMap(t, value);
}

set() The logic of the method is as follows ：

• Get the current thread
• Get a from the current thread ThreadLocalMap object
• If map Not for null Save
• If map by null Then create a map

getMap() and createMap() What have the methods done ？ Let's go in and have a look ：

ThreadLocalMap getMap(Thread t) {
   return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
   t.threadLocals = new ThreadLocalMap(this, firstValue);
}

After entering the two methods, I found , No matter which branch you take , Finally, the value is saved to the current thread threadLocals Properties of the .

see Thread Class source code , You will find that there is a threadLocals attribute , And the initial value is null, The type of ThreadLocal.ThreadLocalMap.

public class Thread implements Runnable {
// ...
   ThreadLocal.ThreadLocalMap threadLocals = null;
// ...
}

Here we are , We found out , original ThreadLocal Is to put the object we want to pass into the current thread threadLocals Properties of the . That is, each thread is using ThreadLocal When you save an object , In fact, the object is placed in the current thread instance object threadLocals Attributes inside . In this way, threads are naturally independent of each other .

I want to see others get() Method ：

public T get() {
   Thread t = Thread.currentThread();
   ThreadLocalMap map = getMap(t);
   if (map != null) {
       ThreadLocalMap.Entry e = map.getEntry(this);
       if (e != null) {
           @SuppressWarnings("unchecked")
           T result = (T)e.value;
           return result;
      }
  }
   return setInitialValue();
}

private T setInitialValue() {
   T value = initialValue();
   Thread t = Thread.currentThread();
   ThreadLocalMap map = getMap(t);
   if (map != null)
       map.set(this, value);
   else
       createMap(t, value);
   return value;
}

ThreadLocal Of get() The method is actually the same as set() The method logic is very similar , From the current thread of threadLocals Property , If the property is null, So initialize .

When the thread ends , Will call the current thread instance exit() Method , take threadLocals Set to null, So that the garbage collector can recycle it .

// THread  Methods in class 
private void exit() {
   // ...
   threadLocals = null;
   // ...
}

Last , One thing needs special attention ： run out ThreadLocal Be sure to call manually remove() Method , Otherwise, dirty data or even memory leaks may occur .

Why? ？ The above does not mean that when the thread ends , Will threadLocals Set as null Do you ？

Yes , At the end of the thread , Do clean up .

but , What if the thread never ends ？ What if threads will be reused ？ For example, thread pool is used .

therefore , Use ThreadLocal Be sure to manually remove().​