Java源码分析-带你认识ThreadLocal的原理

前言

  ThreadLocal是开发中常会使用的一个工具，从类的名字就可以看出，它为线程提供本地变量。即：每个线程私有的数据。提供的实际上就是一种线程隔离，不同的线程的变量归属不同的线程，线程之间不能想问访问各自的变量，当线程生命周期结束的时候，线程会被销毁。之前只知道它的作用，大概还了解一点原理知道内部用的是Map，今天又遇见了，于是有了这篇源码分析。

使用方法

Entity 存放线程要保存的信息

ThreadLocal threadLocal = new ThreadLocal();

//为线程设置私有数据

threadLocal.set(new Entity());

//拿出线程私有数据

threadLocal.get();

Thread成员变量

public class Thread implements Runnable {

   //每一个线程会有唯一的一个ThreadLocalMap类型变量，用来保存该线程所有的私有数据

   ThreadLocal.ThreadLocalMap threadLocals = null;

}

成员变量

线程hashcode值来标识线程，nextHashCode()是获得下一次的值

private final int threadLocalHashCode = nextHashCode();

AtomicInteger类型的hashcode，从0开始

private static AtomicInteger nextHashCode = new AtomicInteger();

每次hash增长的值

private static final int HASH_INCREMENT = 0x61c88647;

AtomicInteger是通过自选式的CAS操作来维护原子性的，读取，计算。

构造函数

 public ThreadLocal()  {}

构造函数很简单，啥也没有。

set方法

        ThreadLocalMap的set()方法，从上面知道每一个线程有个ThreadLocalMap的实例，用来保存该线程的私有数据(一个线程可能会存很多不同类型的私有数据)。

public void set(T value) {

        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        //该线程的threadLocals已经初始化过，则调用ThreadLocalMap的set()方法，

         将数据push进来，否则调用createMap()函数初始化该变量

         if (map != null)

            map.set(this, value);

         else

            createMap(t, value);

     }

        关键的是getMap这个方法，它把Thread传进getMap去获得ThreadLocalMap。ThreadLocal.ThreadLocalMap threadLocals = null；虽然写在了Thread中，但是用的确实ThreadLocal中的map。初次使用map一定为空，这个时候就会创建map。

getMap方法

ThreadLocalMap getMap(Thread t) {

       //返回该线程的threadLocals变量

        return t.threadLocals;

 }

createMap方法

void createMap(Thread t,T firstValue){

    t.threadLocals = new ThreadLocalMap(this,firstValue);

}

ThreadLocalMap

  抛砖引玉，我们进入ThreadLocalMap中，ThreadLocalMap 构造方法：

ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {

           //数据是保存在一个数组里面的，初始长度为16

            table = new Entry[INITIAL_CAPACITY];

          //计算数据放在数组的哪个位置，根据ThreadLocal 的threadLocalHashCode值来计算的

            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

            //以ThreadLocal实例为key，放入实际的数据

            table[i] = new Entry(firstKey, firstValue);

            size = 1;

            setThreshold(INITIAL_CAPACITY);

}

   由这个构造函数，我们可以画出ThreadLocal所用的map结构。

ThreadLocal的对象引用关系

       图中，黄线代表弱引用。我们挑出这两个重要的引用，别的不用特别看。需要注意的是，当弱引用作为不可达对象的时候，会在下一次GC的时候会被回收。Entry是继承了弱引用的。脑子里先有这个大体架构。

Entry

Entry类实际存储着数据，继承 WeakReference 

static class Entry extends WeakReference> {

            /** The value associated with this ThreadLocal. */

            Object value;

            Entry(ThreadLocal k, Object v) {

                super(k);

                //保存放进来的线程私有数据

                value = v;

            }

}

set方法

ThreadLocalMap set方法

private void set(ThreadLocal key, Object value) {

            Entry[] tab = table;

            int len = tab.length;

            //计算数据放入的位置

            int i = key.threadLocalHashCode & (len-1);

            //检测hash冲突，如果该位置已经放入了一个数据(e!=null)，则线性地向后查找第一个合适的位置

            for (Entry e = tab[i];

                e != null;

                e = tab[i = nextIndex(i, len)]) {

                //Entry 继承自WeakReference，所以用get()方法，可以直接拿到需要的key(ThreadLocal的实例)

                ThreadLocal k = e.get();

                //找到一个位置，k和当前要插入的key值相同，更新该位置的数据

                if (k == key) {

                    e.value = value;

                    return;

                }

              //找到一个位置已经有数据，但是key为null，则替换掉废弃的key

                if (k == null) {

                    replaceStaleEntry(key, value, i);

                    return;

                }

            }

            //将key-value存储到Entry中，放在数组的i位置

            tab[i] = new Entry(key, value);

            int sz = ++size;

            //判断是否需要扩展数组，这里是长度大于数组长度的2/3时扩展数组

            if (!cleanSomeSlots(i, sz) && sz >= threshold)

                rehash();

}

  代码逻辑比hashMap简单多了，hashMap是拉链法，它这边直接使用的table数组，如果那个位置已经有了对象，就nextIndex，探测下一个位置，就是标准的线性探测法解决冲突，HashMap是链地址法。就是如果冲突了就向后再挂一个对象。由此我们引入内存泄露的问题。

       以上就将某个数据保存到线程私有数据中了，总结一下：Thread中有个ThreadLocalMap实例，ThreadLocalMap中有个数组：Entry[] table；，Entry中实际保存了数据value。也就是说一个线程可以有n多个私有数据，存放在ThreadLocalMap中，每一个私有数据对应一个ThreadLocal实例和一个Entry实例。

取出数据

ThreadLocal的get()方法：

public T get() {

        Thread t = Thread.currentThread();

        //还是首先要拿到ThreadLocalMap实例

        ThreadLocalMap map = getMap(t);

        if (map != null) {

        //以自己为key，从map中取出实际保存的数据，上面说过：数据是以ThreadLocal为key，实际数据为value 

        // 保存到Entry对象中的

            ThreadLocalMap.Entry e = map.getEntry(this);

            if (e != null) {

                @SuppressWarnings("unchecked")

                T result = (T) e.value;

                return result;

            }

        }

        return setInitialValue();

}

ThreadLocalMap的getEntry()方法：

private Entry getEntry(ThreadLocal key) {

         //计算数组下标，和放入数据时一样

            int i = key.threadLocalHashCode & (table.length - 1);

            Entry e = table[i];

            //当前位置有数据，且key和要需要的一致，说明该位置保存了要的数据

            if (e != null && e.get() == key)

                return e;

            else

                //散列冲突，根据需要的key线性向后查找

                return getEntryAfterMiss(key, i, e);

}

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(i)，也执行了一次清理。

remove方法

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;

                }

            }

}

remove方法是最正宗的手动清除了

get和set、remove的分析

  由上面的分析不难发现，在进行set方法的时候是清除some，get和remove的时候是大清除，如果是同一个线程执行代码的话，那么还可以通过多次的get，set进行清楚，如果是多线程的环境下，你用了不remove，极有可能会造成内存泄漏，不完全清理的问题也可能存在。

内存泄露

cleanSomeSlots

       这里面的细节小逻辑，新手也看不懂，但是需要挑出来的是这里的cleanSomeSlots，清除引用，因为key ThreadLocal是弱引用，当外面没有强引用引用它的时候，即成为无法到达的key将会被GC掉，但是这个时候会存在键为null的value还没有被清除，所以就要通过这个方法去清除。这个清除方法就不贴出来了，只要知道它是一次遍历看看有哪些key为null的，然后将值设置为null来帮助GC。

总结

       总结下来就是，set方法会触发一次清除弱引用残留下来的value值。同样get和remove也会进行清理。线程不结束，那么这个Thread引用链将会永远存在。所以用完了remove掉是个好习惯。也是必须这样用的。

  此次就ThreadLocal这个类的实现进行了分析，从get、set、remove这三个方法把内存泄漏的问题搞清楚了，它的内部是Thread维护的一个Map属性，键是ThreadLocal变量key，值是set进去的值，冲突处理是线性探测法。

经典一句:

        同步机制以时间换空间，多个线程排队等待资源释放。ThreadLocal空间换时间每个线程单独一份资源，互不相干。妙哉妙哉。

参考链接

https://www.sczyh30.com/posts/Java/java-concurrent-threadlocal/

http://blog.xiaohansong.com/2016/08/06/ThreadLocal-memory-leak/

       为什么ThreadLocal内部用的是弱引用？大概是因为内部ThreadLocalMap不是人new出来的，它不归人管，而是在内部使用的，倘若new出来的ThreadLocal变量被gc了，那么ThreadLocalMap中引用ThreadLocal的Entry也应该被gc，这就是所说的弱引用一旦没有了别处的引用就会被gc这个道理，Entry继承的是WeakReference，它应该被回收，毕竟key是ThreadLocal

实际案例

public class HelloWorldExample extends HttpServlet {

    private static final long serialVersionUID = 1L;

    static class LocalVariable {

        private Long[] a = new Long[1024 * 1024 * 100];

    }

    final static ThreadLocal localVariable = new ThreadLocal();

    @Override

    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, 

    ServletException {

        //(2)

        localVariable.set(new LocalVariable());

        response.setContentType("text/html");

        PrintWriter out = response.getWriter();

        out.println("");

        out.println("");

        out.println("");

        out.println("");

        out.println("");

        //(3)

        out.println(this.toString());

        //(4)

        out.println(Thread.currentThread().toString());

        out.println("");

        out.println("");

    }

}

       在Servlet中，有一个类为ThreadLocal的静态变量，打个比方，如果说有5个线程访问这个Servlet实例，Servlet 为5个线程都创建了map，但是没有进行remove久而久之内存自然会蹭蹭往上，用完了线程没有被销毁而是回到了线程池里面，当Thread被销毁了还好，强引用链断了，自然就会被销毁了。官方tomcat在7.0+的时候会解决这个问题，上面的from连接最后给出了答案，重新启动的时候线程会被renew。

      不得不注意的问题: 试想一下，当Thread被销毁的时候，静态变量是在类加载的时候就初始化了的，所以说内存中除非JVM停掉，那么这个静态变量永远会存在，即使Thread线程被回收了，那么这个ThreadLocal引用还是存在的，所以remove方法对ThreadLocalMap中的引用清除是清除了就是说map里面的Entry被清掉了，但是这个强引用new 出来的实例依旧是存在的。

总结一下: 用完了就remove掉，静态变量会一直存在。