一、学习目标

1、ThreadLocal能处理什么问题？

2、ThreadLocal相比synchronized、volatile的优势在哪里？

• synchronized：在并发量小的情况下还好，假如并发量较大时，会有大量的线程等待同一个对象锁，会造成系统吞吐量直线下降。
• volatile：修饰的变量不保留拷贝，直接访问主内存，主要用于一写多读的场景
• ThreadLocal：给每一个线程都创立变量的副本，保证每个线程访问都是自己的副本，相互隔离，就不会出现线程安全问题

二、ThreadLocal的使用

1、线程不安全：

public class ThreadA extends Thread {    private int i;    private UnsafeThread unsafeThread;    ThreadA(int i, UnsafeThread unsafeThread) {        this.i = i;        this.unsafeThread = unsafeThread;    }    @Override    public void run() {        try {            Thread.sleep(10);        } catch (InterruptedException e) {            e.printStackTrace();        }        unsafeThread.calc();        System.out.println("i:" + i + ",count:" + unsafeThread.getCount());    }}public class UnsafeThread {    private int count = 0;    public void calc() {        count++;    }    public int getCount() {        return count;    }    public static void main(String[] args) throws InterruptedException {        UnsafeThread testThread = new UnsafeThread();        for (int i = 0; i < 20; i++) {            new ThreadA(i, testThread).start();        }        Thread.sleep(200);        System.out.println("realCount:" + testThread.getCount());    }}

运行结果：

i:6,count:8i:0,count:8i:17,count:13i:7,count:8i:2,count:8i:11,count:8i:8,count:11i:5,count:11i:13,count:11i:15,count:11i:14,count:11i:10,count:8i:3,count:11i:12,count:11i:9,count:8i:19,count:15i:4,count:15i:16,count:15i:1,count:15i:18,count:15realCount:15

我们可以看到：出现了线程安全问题

• realCount最终出现错误，估计的结果应该是20，实际情况却是15
• count出现重复

2、加入ThreadLocal，线程安全：

public class ThreadA extends Thread {    private int i;    private UnsafeThread unsafeThread;    ThreadA(int i, UnsafeThread unsafeThread) {        this.i = i;        this.unsafeThread = unsafeThread;    }    @Override    public void run() {        try {            Thread.sleep(10);        } catch (InterruptedException e) {            e.printStackTrace();        }        unsafeThread.calc();        System.out.println("i:" + i + ",count:" + unsafeThread.getCount());    }}public class SafeThread {    private ThreadLocal<Integer> threadLocal = new ThreadLocal<>();    private int count = 0;    public void calc() {        threadLocal.set(count + 1);    }    public int getCount() {        Integer integer = threadLocal.get();        return integer != null ? integer : 0;    }    public static void main(String[] args) throws InterruptedException {        SafeThread testThreadLocal = new SafeThread();        for (int i = 0; i < 20; i++) {            new ThreadB(i, testThreadLocal).start();        }        Thread.sleep(200);        System.out.println("realCount:" + testThreadLocal.getCount());    }}

运行结果：

i:1,count:1i:10,count:1i:4,count:1i:11,count:1i:6,count:1i:7,count:1i:9,count:1i:3,count:1i:12,count:1i:0,count:1i:5,count:1i:8,count:1i:2,count:1i:13,count:1i:17,count:1i:18,count:1i:15,count:1i:19,count:1i:16,count:1i:14,count:1realCount:0

三、ThreadLocal的工作原理

1、线程不安全：

吾日三省吾身——ThreadLocal深入剖析

我们可以看到多个线程可以同时访问公共资源count，当某个线程在执行count++的时候，可能其余的线程正好同时也执行count++。但因为多个线程变量count的不可见性，会导致另外的线程拿到旧的count值+1，这样就出现了realCount估计是20，但是实际上是15的数据问题。

2、线程安全：

吾日三省吾身——ThreadLocal深入剖析

如图所示：

• 往大的方向上说，ThreadLocal会给每一个线程都创立变量的副本，保证每个线程访问都是自己的副本，相互隔离。
• 往小的方向上说， 每个线程内部都有一个threadLocalMap，每个threadLocalMap里面都包含了一个entry数组，而entry是由threadLocal和数据（这里指的是count）组成的。

这样一来，每个线程都拥有自己专属的变量count。

示例2中，线程1调用calc方法时，会先调用的getCount方法，因为第一次调用threadLocal.get()返回是空的，所以getCount返回值是0。这样threadLocal.set(getCount() + 1)，就变成了threadLocal.set(0 + 1)，它会给线程1中threadLocal的数据值设置成1。

线程2再调用calc方法，同样会先调用getCount方法，因为第一次调用threadLocal.get()返回是空的，所以getCount返回值也是0。这样threadLocal.set(getCount() + 1)，会给线程2中threadLocal的数据值也设置成1。

……

最后每个线程的threadLocal中的数据值都是1。

还有，示例2中打印出来的realCount为什么是0呢？

• 由于testThreadLocal.getCount()是在主线程中调用的，其余的线程改变只会影响自己的副本，不会影响原始变量，count初始值是0，所以最后还是0。

四、ThreadLocal的源码解析

1、Thread：

ThreadLocal.ThreadLocalMap threadLocals = null;

定义了一个叫threadLocals的成员变量，它的类型是ThreadLocal.ThreadLocalMap。很显著ThreadLocalMap是ThreadLocal的内部类，验证了我在图中画的内容， 每个线程都有一个ThreadLocalMap对象。

2、ThreadLocalMap：

static class ThreadLocalMap {    // Entry是WeakReference（弱引用）的子类    static class Entry extends WeakReference<ThreadLocal<?>> {        Object value;        // Entry 包含了 ThreadLocal变量 和Object的value        Entry(ThreadLocal<?> k, Object v) {            // ThreadLocal变量做为WeakReference的referen            super(k);            value = v;        }    }    private static final int INITIAL_CAPACITY = 16;    // 数组，它的类型是Entry    private Entry[] table;    private int size = 0;    private int threshold; // Default to 0    private void setThreshold(int len) {        threshold = len * 2 / 3;    }    ...}    

3、ThreadLocal#get()：

public T get() {    //获取当前线程    Thread t = Thread.currentThread();    //获取当前线程中的ThreadLocalMap对象    ThreadLocalMap map = getMap(t);    //假如可以查询到数据    if (map != null) {        //从ThreadLocalMap中获取entry对象        ThreadLocalMap.Entry e = map.getEntry(this);        //假如entry存在        if (e != null) {            @SuppressWarnings("unchecked")            //获取entry中的值            T result = (T)e.value;            //返回获取到的值            return result;        }    }    //调用初始化方法，返回null    return setInitialValue();}

ThreadLocal#getMap(t)：

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

实际上是调用Thread类的变量：

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal#getEntry(ThreadLocal<?> key)：

private Entry getEntry(ThreadLocal<?> key) {    //threadLocalHashCode是key的hash值    //key.threadLocalHashCode & (table.length - 1)，    //相当于threadLocalHashCode对table.length - 1的取余操作，    //这样可以保证数组的下表在0到table.length - 1之间。    int i = key.threadLocalHashCode & (table.length - 1);    //获取下标对应的entry    Entry e = table[i];    //假如entry不为空，并且从弱引用中获取到的值(threadLocal) 和 key相同     if (e != null && e.get() == key)        //返回获取到的entry        return e;    else       //假如没有获取到entry或者者e.get()获取不到数据，则清除空数据        return getEntryAfterMiss(key, i, e);}

entry是WeakReference的子类，那么e.get()方法会调用：Refernt#get()

public T get() {  return this.referent;}

返回的是一个引用，这个引用就是构造器传入的threadLocal对象。

吾日三省吾身——ThreadLocal深入剖析

ThreadLocal#getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e)

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {    Entry[] tab = table;    int len = tab.length;    while (e != null) {        ThreadLocal<?> k = e.get();        if (k == key)            return e;        if (k == null)            expungeStaleEntry(i);        else            i = nextIndex(i, len);        e = tab[i];    }    return null;}

该方法里面会调用expungeStaleEntry方法，后面我们会重点详情的

ThreadLocal#setInitialValue()：

private T setInitialValue() {    //调用客户自己设置的initialValue方法，默认值是null    T value = initialValue();    //获取当前线程    Thread t = Thread.currentThread();    //获取当前线程中的ThreadLocalMap，跟之前一样    ThreadLocalMap map = getMap(t);    //假如ThreadLocalMap不为空，    if (map != null)        //则覆盖key为当前threadLocal的值        map.set(this, value);    else       //否则创立新的ThreadLocalMap        createMap(t, value);    //返回客户自己设置的值        return value;}

4、ThreadLocal#set()：

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

ThreadLocal.ThreadLocalMap#set(ThreadLocal<?> key, Object value)：

private void set(ThreadLocal<?> key, Object value) {    //将table数组赋值给新数组tab    Entry[] tab = table;    //获取数组长度    int len = tab.length;    //跟之前一样计算数组中的下表    int i = key.threadLocalHashCode & (len-1);    //循环变量tab获取entry    for (Entry e = tab[i];         e != null;         e = tab[i = nextIndex(i, len)]) {        //获取entry中的threadLocal对象         ThreadLocal<?> k = e.get();        //假如threadLocal对象不为空，并且等于key        if (k == key) {            //覆盖已有数据            e.value = value;            //返回            return;        }        //假如threadLocal对象为空        if (k == null) {            //创立一个新的entry赋值给已有key            replaceStaleEntry(key, value, i);            return;        }    }    //假如key不在已有数据中，则创立一个新的entry    tab[i] = new Entry(key, value);    //长度+1    int sz = ++size;    if (!cleanSomeSlots(i, sz) && sz >= threshold)        rehash();}

replaceStaleEntry方法也会调用expungeStaleEntry方法。

5、ThreadLocal#remove()：

public void remove() { //还是那个套路，不过简化了一下 //先获取当前线程，再获取线程中的ThreadLocalMap对象 ThreadLocalMap m = getMap(Thread.currentThread()); //假如ThreadLocalMap不为空 if (m != null)     //删除数据     m.remove(this);}

ThreadLocal.ThreadLocalMap#remove(ThreadLocal<?> key)：

private void remove(ThreadLocal<?> key) {    //将table数组赋值给新数组tab    Entry[] tab = table;    //获取数组长度    int len = tab.length;    //跟之前一样计算数组中的下表    int i = key.threadLocalHashCode & (len-1);    //循环变量从下表i之后不为空的entry    for (Entry e = tab[i];         e != null;         e = tab[i = nextIndex(i, len)]) {        //假如可以获取到threadLocal并且值等于key         if (e.get() == key) {            //清空引用            e.clear();            //解决threadLocal为空但是value不为空的entry            expungeStaleEntry(i);            return;        }    }}

其中的clear方法，也很简单，只是把引用设置为null，即清空引用

public void clear() {    this.referent = null;}

ThreadLocal#expungeStaleEntry(int staleSlot)

private int expungeStaleEntry(int staleSlot) {    Entry[] tab = table;    int len = tab.length;    //将位置staleSlot对应的entry中的value设置为null，有助于垃圾回收    tab[staleSlot].value = null;    //将位置staleSlot对应的entry设置为null，有助于垃圾回收    tab[staleSlot] = null;    //数组大小-1    size--;    Entry e;    int i;    //变量staleSlot之后entry不为空的数据    for (i = nextIndex(staleSlot, len);         (e = tab[i]) != null;         i = nextIndex(i, len)) {        //获取当前位置的entry中对应的threadLocal         ThreadLocal<?> k = e.get();        //threadLocal为空，说明是脏数据        if (k == null) {            //value设置为null，有助于垃圾回收            e.value = null;            //当前位置的entry设置为null            tab[i] = null;            //数组大小-1            size--;        } else {            //重新计算位置            int h = k.threadLocalHashCode & (len - 1);            //假如h和i不相等，说明存在hash冲突            //现在它前面的脏Entry被清除            //该Entry需要向前移动，防止下次get()或者set()的时候            //再次因散列冲突而查找到null值            if (h != i) {                tab[i] = null;                while (tab[h] != null)                    h = nextIndex(h, len);                tab[h] = e;            }        }    }    return i;}

该方法首先清理当前位置的脏Entry，而后向后遍历直到table[i]==null。在遍历的过程中假如再次遇到脏Entry就会清除。

假如没有遇到就会重新变量当前遇到的Entry，假如重新散列得到的下标h与当前下标i不一致，说明该Entry被放入Entry数组的时候发生了散列冲突（其位置通过再散列被向后偏移了），现在其前面的脏Entry已经被清理，所以当前Entry应该向前移动，补上空位置。否则下次调用set()或者get()方法查找该Entry的时候会查找到位于其之前的null值。

为什么要做这样的清理？

• 我们知道entry对象里面包含了threadLocal和value，threadLocal是WeakReference（弱引用）的referent。每次垃圾回收期触发GC的时候，都会回收WeakReference的referent，会将referent设置为null。那么table数组中就会存在很多threadLocal = null 但是 value不为空的entry，这种entry的存在是没有任何实际价值的。
• 这种数据通过getEntry是获取不到值，由于它里面有if (e != null && e.get() == key)这句判断。

为什么要使用WeakReference（弱引用）？

• 避免内存泄漏：假如使用强引用，ThreadLocal在客户进程不再被引用，但是只需线程不结束，在ThreadLocalMap中就还存在引用，无法被GC回收，会导致内存泄漏。
• 另外在使用线程池技术的时候，因为线程不会被销毁，回收之后，下一次又会被重复利用，会导致ThreadLocal无法被释放，最终也会导致内存泄露问题。

四、ThreadLocal有哪些坑

1、内存泄露问题：

ThreadLocal即便使用了WeakReference（弱引用）也可能会存在内存泄露问题，由于 entry对象中只把key(即threadLocal对象)设置成了弱引用，但是value值没有。还是会存在下面的强依赖：

Thread -> ThreaLocalMap -> Entry -> value

处理方案：

• 调用get()、set(T value) ， 但是 get()和set(T value) 方法是基于垃圾回收器把key回收之后的基础之上触发的数据清除。假如出现垃圾回收器回收不及时的情况，也一样有问题。
• 调用remove()，该方法会把entry中的key(即threadLocal对象)和value一起清空。

2、线程安全问题：

可能有些朋友认为使用了threadLocal就不会出现线程安全问题了，其实是不对的。 如果我们定义了一个static的变量count，多线程的情况下，threadLocal中的value需要修改并设置count的值，它一样有问题。由于static的变量是多个线程共享的，不会再单独保存副本。

五、总结：

1、每个线程都有一个threadLocalMap对象，每个threadLocalMap里面都包含了一个entry数组，而entry是由key（即threadLocal）和value（数据）组成。

2、entry的key是弱引用，可以被垃圾回收器回收。

3、threadLocal最常用的这四个方法：get()， initialValue()，set(T value) 和 remove()，除了initialValue方法，其余的方法都会调用expungeStaleEntry方法做key==null的数据清除工作，以便于垃圾回收。

4、调用get()、set(T value) ， 但是 get()和set(T value) 方法是基于垃圾回收器把key回收之后的基础之上触发的数据清除。假如出现垃圾回收器回收不及时的情况，也一样有问题内存泄漏问题，最保险是在使用完threadLocal之后，手动调用一下remove方法，从源码可以看到，该方法会把entry中的key(即threadLocal对象)和value一起清空。

来源：https://www.tuicool.com/articles/FN3AnqZ