线程内部存储ThreadLocal

1、是什么？

并发访问共享变量的时候可以考虑加锁控制(synchornized、Lock锁、volatile+cas)这种方式对内存友好，不用额外的开辟线程内的存储空间，但是并发的时候要互斥访问对效率不太友好；

早在JDK1.2的就提供了ThreadLocal的线程内部存储机制来解决并发访问题。设计思想是在线程内部存储共享变量的副本，在线程存活的过程中可以随时随意场景中取到自己保存的变量副本。

2、怎么使用？

import java.util.concurrent.TimeUnit;

public class LocalThreadTest {

    public static void main(String[] args){

        Resource res  = new Resource();
        new Thread(()->{

            try {
                res.addNum(1);
                TimeUnit.SECONDS.sleep(1);
                res.print();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程1").start();
        new Thread(()->{
            res.addNum(2);
            res.print();
        },"线程2").start();
        new Thread(()->{
            res.addNum(3);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            res.print();
        },"线程3").start();
    }
    static class  Resource{
        ThreadLocal <Object> local = new ThreadLocal<>();
        int num;

        void addNum(int num){
            this.num = num;
            local.set(num);
        }

        void print(){
            System.out.println(Thread.currentThread().getName()+"------>"+local.get());
            local.remove();
        }
    }
}

结果：

3、内部结构

在每个Thread对象的内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals。这是一个Map对象，存储键值对，但是并不是Map接口下的子类，而是ThreadLocal的中的内部类，

    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;

从其内部结构我们可以得到：ThreadLocal类中有一个Entry内部类，这里的Entry类的k被做了弱引用，内部维护了一个Entry数组，初始容量元素个数是16，hash是threadLocalHashCode，计算方式是new AtomicInteger()+HASH_INCREMENT(0x61c88647)。

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

Thread---->currentThread---->ThreadLocalMap--->set(this,value)

可以看出其实操作的是当前线程中的threadLocals变量，ThreadLocal对象为key，要存储的数据为Val。

同理get()、remove()方法都是操作的Thread中的ThreadLocalMap。

4、ThreadLocal作为key为什么要用弱引用？

结构图：（来自百度图片）

当我们程序方法运行结束的时候，栈中的ThreadLocalRef引用出栈，ThreadLocal对象唯一存在的引用就是Entry对象引用的弱引用，那么在下一次GC的时候不论虚拟机内存是否够用都会回收ThreadLocal对象，但是如果是强引用的类型的Entry的话，那么在线程未被销毁之前，ThreadLocal对象会一直有一个强引用，不会被GC。

5、继承了WeakReference类为什么还会有内存泄露问题？

在使用过程中，在线程销毁之前，一直存在entry中的Value--->Object的强引用，原因是Thread中的ThreadLocalMap的entry一直存在。如果没有使用线程池的情况下内存泄露的情况还好，只是在线程回收之前，线程被销毁，那么Object最后一定会被回收。

但是我们在实际的工程中通常都是使用线程池，那么线程会不断被复用，Thread对象一直存在，ThreadLocalMap中的Entry一直存在，尽管key可能已经为null了，但是value对Object的强引用一直存在，Object就无法被回收。出现内存泄漏的情况。

6、内存泄漏的解决？

其实ThreadLocal在它的代码逻辑中已经尽量避免内存泄漏了。

比如get()、set()、remove()的时候都会清除线程ThreadLocalMap里所有key为null的value。

        private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, 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)//如果key是null，下面方法把value也设为null
                    expungeStaleEntry(i);
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }
       private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

如果使用之后一直没有调用get、set方法呢？

我们在使用玩，方法结束的时候，手动调用一下remove()就可以了。