关于java:面试时被问到threadLocal别慌你要的答案都在这里

敌人们在遇到线程平安问题的时候，大多数状况下可能会应用synchronized关键字，每次只容许一个线程进入锁定的办法或代码块，这样就能够保障操作的原子性，保障对公共资源的批改不会呈现莫名其妙的问题。这种加锁的机制，在并发量小的状况下还好，如果并发量较大时，会有大量的线程期待同一个对象锁，会造成零碎吞吐量直线降落。

JDK的开发者可能也思考到应用synchronized的弊病，于是呈现了volatile 和 ThreadLocal等另外的思路解决线程平安问题。volatile它所润饰的变量不保留拷贝，间接拜访主内存，次要用于一写多读的场景。ThreadLocal是给每一个线程都创立变量的正本，保障每个线程拜访都是本人的正本，互相隔离，就不会呈现线程平安问题，这种形式其实用空间换工夫的做法。其余的内容当前有空再探讨，明天咱们重点聊一下 ThreadLocal。

接下来，咱们将从以下几个方面介绍ThreadLocal

如何应用ThreadLocal？
ThreadLocal的工作原理
ThreadLocal源码解析
ThreadLocal有哪些坑

1.如何应用ThreadLocal？

在应用ThreadLocal之前咱们先一起看个例子

/** * 不平安线程场景 * * @author sue * @date 2020/8/12 21:21 */public class TestThread {    private int count = 0;    public void calc() {        count++;    }    public int getCount() {        return count;    }    public static void main(String[] args) throws InterruptedException {        TestThread testThread = new TestThread();        for (int i = 0; i < 20; i++) {            new ThreadA(i, testThread).start();        }        Thread.sleep(200);        System.out.println("realCount:" + testThread.getCount());    }}class ThreadA extends Thread {    private int i;    private TestThread testThread;    ThreadA(int i, TestThread testThread) {        this.i = i;        this.testThread = testThread;    }    public void run() {        try {            Thread.sleep(10);        } catch (InterruptedException e) {            e.printStackTrace();        }        testThread.calc();        System.out.println("i:" + i + ",count:" + testThread.getCount());    }}

运行后果：

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

咱们能够看到，realCount最终呈现谬误，预计的后果应该是20，理论状况却是18，呈现了线程平安问题。

接下来，把程序改成ThreadLocal运行后果会怎么？

/** * ThreadLocal场景 * * @author sue * @date 2020/8/12 21:21 */public class TestThreadLocal {    private ThreadLocal<Integer> threadLocal = new ThreadLocal<>();    public void calc() {        threadLocal.set(getCount() + 1);    }    public int getCount() {        Integer integer = threadLocal.get();        return integer != null ? integer : 0;    }    public static void main(String[] args) throws InterruptedException {        TestThreadLocal testThreadLocal = new TestThreadLocal();        for (int i = 0; i < 20; i++) {            new ThreadB(i, testThreadLocal).start();        }        Thread.sleep(200);        System.out.println("realCount:" + testThreadLocal.getCount());    }}class ThreadB extends Thread {    private int i;    private TestThreadLocal testThreadLocal;    ThreadB(int i, TestThreadLocal testThreadLocal) {        this.i = i;        this.testThreadLocal = testThreadLocal;    }    public void run() {        try {            Thread.sleep(10);        } catch (InterruptedException e) {            e.printStackTrace();        }        testThreadLocal.calc();        System.out.println("i:" + i + ",count:" + testThreadLocal.getCount());    }}

运行后果：

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

咱们能够看到，跟之前的例子运行后果差异很大，首先当初count全部都是1，之前count有8，10，11，12等很多值。其次realCount之前是18，当初的realCount却是0。为什么会造成这样的差别呢？

2.ThreadLocal的工作原理

先看看示例1中的状况

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

再看看示例2中的状况：

如图所示，往大的方向上说，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。

**3.ThreadLocal源码解析
**

在介绍ThreadLocal之前，让咱们一起先看看Thread类

ThreadLocal.ThreadLocalMap threadLocals = null;

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

咱们再重点看看ThreadLocalMap

static class ThreadLocalMap {      static class Entry extends WeakReference<ThreadLocal<?>> {          /** The value associated with this ThreadLocal. */          Object value;          Entry(ThreadLocal<?> k, Object v) {              super(k);              value = v;          }      }      /**       * The initial capacity -- MUST be a power of two.       */      private static final int INITIAL_CAPACITY = 16;      /**       * The table, resized as necessary.       * table.length MUST always be a power of two.       */      private Entry[] table;      /**       * The number of entries in the table.       */      private int size = 0;      /**       * The next size value at which to resize.       */      private int threshold; // Default to 0      /**       * Set the resize threshold to maintain at worst a 2/3 load factor.       */      private void setThreshold(int len) {          threshold = len * 2 / 3;      }       ........省略  }

因为该办法太长了，我在这里省略了局部内容。从以上代码能够看到ThreadLocalMap外面蕴含了一个叫table的数组，它的类型是Entry，Entry是WeakReference（弱援用）的子类，Entry又蕴含了 ThreadLocal变量和Object的value ，其中ThreadLocal变量做为WeakReference的referent。

接下来，咱们再回到ThreadLocal类，罕用的其实就上面四个办法：get()， initialValue()，set(T value) 和 remove()，接下来咱们会逐个介绍。

首先看看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;        }    }    //调用初始化办法    return setInitialValue();}

其中的getMap办法

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

再简略不过了，间接返回的是以后线程的成员变量threadLocals

再看看getEntry办法

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()办法会调用：

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

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

getEntryAfterMiss外面有阐明逻辑呢？

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办法，前面咱们会重点介绍的。

再看看setInitialValue办法

protected T initialValue() {

return null;

}

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;}

当中的initialValue()办法，就是咱们要介绍的第二个办法

  protected T initialValue() {      return null;  }

咱们能够看到该办法只有一个空实现，等着用户的子类重写之后从新实现。

接下来重点看看threadLocalMap的set办法

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办法。

再看看setInitialValue办法中的createMap办法

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

代码很简略，就是new了一个ThreadLocalMap对象。

好了，到这来get() 和 initialValue() 办法介绍完了。

上面介绍set(T value) 办法

public void set(T value) {    //获取以后线程，都是一样的套路    Thread t = Thread.currentThread();    //依据以后线程获取当中的ThreadLocalMap    ThreadLocalMap map = getMap(t);    //ThreadLocalMap不为空，则调用之前介绍过的ThreadLocalMap的set办法    if (map != null)        map.set(this, value);    else       //如果ThreadLocalMap为空，则创立一个对象，之前也介绍过        createMap(t, value);}

so easy

最初，看看remove()办法

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

这个办法的要害就在于ThreadLocalMap类的remove办法

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;}

咱们能够看到get()、set(T value) 和 remove()办法，都会调用expungeStaleEntry办法，咱们接下来重点看一下expungeStaleEntry办法

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无奈被开释，最终也会导致内存泄露问题。

4.ThreadLocal有哪些坑

内存泄露问题：

ThreadLocal即便应用了WeakReference（弱援用）也可能会存在内存泄露问题，因为 entry对象中只把key(即threadLocal对象)设置成了弱援用，然而value值没有。还是会存在上面的强依赖：

Thread -> ThreaLocalMap -> Entry -> value

要解决这个问题就须要调用get()、set(T value) 或 remove()办法。然而 get()和set(T value) 办法是基于垃圾回收器把key回收之后的根底之上触发的数据清理。如果呈现垃圾回收器回收不及时的状况，也一样有问题。

所以，最保险的做法是在应用完threadLocal之后，手动调用一下remove办法，从源码能够看到，该办法会把entry中的key(即threadLocal对象)和value一起清空。

线程平安问题：

可能有些敌人认为应用了threadLocal就不会呈现线程平安问题了，其实是不对的。如果咱们定义了一个static的变量count，多线程的状况下，threadLocal中的value须要批改并设置count的值，它一样有问题。因为static的变量是多个线程共享的，不会再独自保留正本。

5.总结

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

2.entry的key是弱援用，能够被垃圾回收器回收。

3.threadLocal最罕用的这四个办法：get()， initialValue()，set(T value) 和 remove()，除了initialValue办法，其余的办法都会调用expungeStaleEntry办法做key==null的数据清理工作。

4.threadLocal可能存在内存泄露和线程平安问题，应用完之后，要手动调用remove办法。

敌人们如果喜爱这篇文章的话，请关注一下我的公众账号：苏三说技术，前面会有很多干货分享，谢谢大家。