JDK源码解析---ThreadLocal

1.概述

维持线程封闭性除了Ad-hoc封闭和栈封闭，更规范的方法是使用ThreadLocal，这个类是java lang包下的一个类。他能使线程中的某个值与保存值的对象关联起来。ThreadLocal提供了get set等访问接口或方法，这些方法为每个使用该变量的线程都存有一份独立地副本，因此get总能返回由当前执行线程在调用set时设置的最新值。

2.属性

private final int threadLocalHashCode = nextHashCode(); //ThreadLocal实例hash值，用来区分不同实例

private static AtomicInteger nextHashCode =
    new AtomicInteger();//可以看作hash值的一个基值

private static final int HASH_INCREMENT = 0x61c88647;//hash值每次增加量

3.内部类 ThreadLocalMap

用于保存线程中的变量使用一个Enrty类型的数组 private Entry[] table;

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

Entry结构如上，并且是一个弱引用的对象。是因为当ThreadLocal指向null的时候，会出现key为空的Entry，对应的value是无法访问到的。便存在着内存泄漏的问题。所以将Enrty设置成弱引用可以避免内存泄漏的问题，这些对象只能存活到下一次垃圾回收之前。

3.1属性

private static final int INITIAL_CAPACITY = 16;//数组初始容量

private Entry[] table;//用于保存变量的数组

private int size = 0;//数组中变量的个数

private int threshold; // 阈值

3.2构造方法

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {//key value
    table = new Entry[INITIAL_CAPACITY];//根据初始容量构建一个Entry数组
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//计算存储的位置
    table[i] = new Entry(firstKey, firstValue);//构建一个保存value的Enrty
    size = 1;//当前数组内元素个数1个
    setThreshold(INITIAL_CAPACITY);//设置阈值为16
}

private ThreadLocalMap(ThreadLocalMap parentMap) {//构建一个新的ThreadLocalMap，继承自参数parenytMap
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];

    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                int h = key.threadLocalHashCode & (len - 1);
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size++;
            }
        }
    }
}

3.3方法

private void setThreshold(int len) {//设置阈值
    threshold = len * 2 / 3;
}

/**
 * Increment i modulo len.
 */
private static int nextIndex(int i, int len) {//下一个索引
    return ((i + 1 < len) ? i + 1 : 0);
}

/**
 * Decrement i modulo len.
 */
private static int prevIndex(int i, int len) {//前一个索引
    return ((i - 1 >= 0) ? i - 1 : len - 1);
}

private Entry getEntry(ThreadLocal<?> key) {//根据key获得Entry，根据传入的key计算hash然后得到数组中的位置。找到了返回，没找到就继续往后找
    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)//当e对应的ThreadLocal和传入的参数key一样的时候返回Enrty
            return e;
        if (k == null)//若e指向的ThreadLocal为空，则将这个Entry对象清空
            expungeStaleEntry(i);
        else//若e指向的ThreadLocal与传入的参数不同，则获取i下一位对应的Entry
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

private void set(ThreadLocal<?> key, Object value) {//添加到数组中
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

  	//先寻找有没有已存在的key对应的元素
    for (Entry e = tab[i];
       e != null;
       e = tab[i = nextIndex(i, len)]) {
       ThreadLocal<?> k = e.get();

       if (k == key) {
           e.value = value;
           return;
       }

       if (k == null) {
           replaceStaleEntry(key, value, i);//替换
           return;
       }
   }

   tab[i] = new Entry(key, value);
   int sz = ++size;
   if (!cleanSomeSlots(i, sz) && sz >= threshold)
   rehash();
}

private void remove(ThreadLocal<?> key) {//移除key对应的Entry
    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;
        }
    }
}
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;
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

4.set方法

public void set(T value) {
    Thread t = Thread.currentThread();//获取当前的线程
    ThreadLocalMap map = getMap(t);//根据当前的线程得到ThreadLocalMap
    if (map != null)//若不为空
        map.set(this, value);//则将ThreadLocal作为key，value作为value保存在map中
    else
        createMap(t, value);//否则新建一个Map
}

5.get方法

public T get() {
    Thread t = Thread.currentThread//获取当前线程
    ThreadLocalMap map = getMap(t);//获取当前线程的ThradLocalMap对象
    if (map != null) {//若不为空
        ThreadLocalMap.Entry e = map.getEntry(this);//从中获取key
        if (e != null) {//key不为空
            @SuppressWarnings("unchecked")
            T result = (T)e.value;//获得值
            return result;
        }
    }
    return setInitialValue();
}

6.remove方法

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

7.应用场景

1. 框架中的应用。Spring采用ThreadLocal的方式，来保证单个线程中的数据库操作使用的是同一个数据库连接。
2. 实际工作中的应用。我们知道SimpleDataFormat不是线程安全的。所以如果声明为全局变量会有并发安全隐患。一般会在使用这个类的方法里创建SimpleDataFormat对象，这样不会有并发隐患。但是方法内部的对象在方法执行完其生命周期就结束了，如果一个请求在调用链路的n个方法中都调用了SimpleDataFormat，是不是要创建n个对象？此时我们可以将其声明为ThreadLocal，一个线程在其生命周期内使用同一个SimpleDataFormat，不同对象之间使用各自的SimpleDataFormat对象，形成线程间的数据隔离，不会有并发安全隐患。然而这种场景，适用于一个线程有多个方法调用都用到了SimpleDataFormat，可以减少创建对象的次数。如果生命周期内只有一个方法使用了这个对象，在方法里创建就好了。
3. 用于传递参数。项目中，一个线程横跨若干个方法调用，需要传递的对象，也就是上下文，它是一种状态，经常就是用户身份、任务信息等，就会存在过渡传参的问题。在线程最开始设置ThreadLocal对象，在线程生命周期的多个方法执行过程中，通过tl.get()就可以取出参数。这种方法可以避免通过方法入参传递变量。

8.内存泄漏问题

1.每次使用完ThreadLocal将tl设置为null 这样ThreadLocal只存在弱引用，下一次gc的时候就会将其回收掉。

2.当ThreadLocal对象被回收后，key指向的就是null 此时无法访问到对应的value，这就造成了内存泄漏的问题。所以需要显示的删除这个键值对。调用tl.remore()。