ThreadLocal深度剖析

ThreadLocal作用：

为每个线程创建一个副本，然后当前线程修改了该副本的值后而不会影响其他线程的值，各个变量之间相互不影响。注意：每个线程在获取实例中的值时，必须先对改值进行初始化，否知获得的值为null。

代码示例如下：

public class ThreadLocalTest {
    // 通过set()方法初始化
    private static final ThreadLocal<Integer> tlInt = new ThreadLocal<>();
    // 通过withInitial()方法初始化
    private static final ThreadLocal<String> tlString = ThreadLocal.withInitial(() -> "Hello, world");
    private static final ThreadLocal<Double> tlDouble = new ThreadLocal<>();

    public static void main(String... args) {
        tlInt.set(6);
        System.out.println("tlInt.get()= "+tlInt.get());
        System.out.println("tlString.get()= "+tlString.get());
        System.out.println("tlDouble.get()= "+tlDouble.get());
    }
}

运行结果如下：

ThreadLocal 类图结构如下：

源码中的定义：
1 static final class SuppliedThreadLocal extends ThreadLocal，SuppliedThreadLocal是ThreadLocal的静态内部类。
2 static class ThreadLocalMap，ThreadLocalMap也是ThreadLocal的静态内部类。
3 static class Entry extends WeakReference<ThreadLocal<?>> ，Entry 是 ThreadLocalMap的静态内部类。

ThreadLocal源码分析：

我们先来看下ThreadLocal的主要方法实现：

1 ThreadLocal中set(T value) 方法解析如下：

public void set(T value) {
            // 获取当前线程
            Thread t = Thread.currentThread();
            // 获取当前线程的 ThreadLocalMap 
            ThreadLocalMap map = getMap(t);
            if (map != null)
            // 如果当前线程的ThreadLocalMap 不为空，直接初始化
                map.set(this, value);
            else
            // 如果当前线程的ThreadLocalMap 为空，则创建ThreadLocalMap 
                createMap(t, value);
        }
        
//根据当前线程获取当前线程的ThreadLocalMap 
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
 }
        
 //key为ThreadLocal实例，value为设置的值，将key-value放入Entry中。
 private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
                if (k == key) {
                    e.value = value;
                    return;
                }
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
  //如果当前线程的ThreadLocalMap
  void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
    
   ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
    }

2 ThreadLocal中get()方法解析如下：

 public T get() {
        // 获取当前线程
        Thread t = Thread.currentThread();
       // 获取当前线程的 ThreadLocalMap 
        ThreadLocalMap map = getMap(t);
        if (map != null) {
          //获取ThreadLocalMap中的Entry ,this 代表ThreadLocal实例
          ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

    // 对ThreadLocal进行初始化，如果没有在代码中显示设置，则setInitialValue() 的返回值为null。
  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;
    }
    
   protected T initialValue() {
        return null;
    }

ThreadLocal 内存泄漏：
先来看下ThreadLocal.ThreadLocalMap.Entry 的类图结构：

源码中的定义如下：

   static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;

        Entry(ThreadLocal<?> k, Object v) {
        // 调用父类构造方法
            super(k);
            value = v;
        }
    }

ThreadLocalMap 使用 ThreadLocal 的弱引用作为key，如果一个 ThreadLocal 没有外部强引用来引用它，那么系统 GC 的时候，这个ThreadLocal 就会被回收，这样一来，ThreadLocalMap 中就会出现 key 为 null 的 Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话，这些key为null的Entry的value永远无法回收，造成内存泄漏。在 ThreadLocal 中 的 get, set 和remove 方法中，都对 Entry 的key进行的null的判断，如果为null，则会 expungeStaleEntry 进行清理操作；
所以，在线程中使用完 ThreadLocal 变量后，要记得及时remove掉。ThreadLocal 源码中的remove()方法如下：

 public void remove() {
             ThreadLocalMap m = getMap(Thread.currentThread());
             if (m != null)
             // 调用remove(ThreadLocal<?> key)删除Entry
                 m.remove(this);
         }

 private void remove(ThreadLocal<?> key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }