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结构。

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

Entry

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

static class Entry extends WeakReference<ThreadLocal<?>> {

** /** 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空间换时间每个线程单独一份资源，互不相干。妙哉妙哉。

为什么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> localVariable = new ThreadLocal<LocalVariable>();

@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("<html>");

    out.println("<head>");

    out.println("<title>" + "title" + "</title>");

    out.println("</head>");

    out.println("<body bgcolor=\"white\">");

    //(3)

    out.println(this.toString());

    //(4)

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

    out.println("</body>");

    out.println("</html>");

}

}

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

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

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