JUC - ThreadLocal

基本

定义

1. ThreadLocal，即线程变量是一个以ThreadLocal对象为键，任意对象为值的存储结构。这个结构会被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值
2. 通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值

图解

源码

nextHashCode

1. 是ThreadLocal 的唯一ID

private final int threadLocalHashCode = nextHashCode();

2. CAS方法：nextHashCode

// static变量，和nextHashCode方法配合产生唯一ID
private static AtomicInteger nextHashCode =
    new AtomicInteger();

private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

// AtomicInteger
public final int getAndAdd(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta);
}

ThreadLocalMap

1. ThreadLocalMap里的getMap方法

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

2. Thread中的ThreadLocalMap

ThreadLocal.ThreadLocalMap threadLocals = null;

3. ThreadLocalMap的数据结构

在ThreadLocal中定义，Thread依赖

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;
        }
        ....
        private Entry[] table;
    }
 }

Entry

static class Entry extends WeakReference<ThreadLocal<?>> {
    Object value;

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

1. ThreadLocal作为弱引用封装到Entry里(作为WeakReference里的T)
2. 即Entry里封装的是 key-value

set方法

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

2. createMap : ThreadLocalMap的构造函数

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


ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
    // 通过Hash值确定索引
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    // private static final int INITIAL_CAPACITY = 16;
    setThreshold(INITIAL_CAPACITY);
}

// 超过长度的2/3时需要扩容
private void setThreshold(int len) {
    threshold = len * 2 / 3;
}

3. ThreadLocalMap的set方法

private void set(ThreadLocal<?> key, Object value) {

    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

   // 若Hash冲突，则会用nextIndex方法，(地址+1)
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();

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

	// k是被回收的弱引用
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 清除key已经为null的Entry，之后size还是大于threshold，则重构
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

get方法

1. 源码

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 如果map还没定义，则new一个map，并返回null
    return setInitialValue();
}

2. map.getEntry

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

关于弱引用和内存泄漏

弱引用

每个thread中都存在一个map，map的类型是ThreadLocal.ThreadLocalMap，先看下图

• Map中的key作为一个threadLocal实例，这个Map使用了弱引用，当把threadlocal实例置为null后，没有任何强引用指向threadlocal实例(堆内存中的实例)，所以此时该实例可以被顺利GC
• 若此时每个key都强引用指向threadlocal，那么这个threadlocal就会因为和entry存在强引用无法被回收，造成内存泄漏，除非线程结束，线程被回收，map也跟着回收，否则将无法被回收

内存泄漏

1. 虽然上述弱引用解决了key的内存泄漏问题，及threadlocal可以被及时回收，但是value却依然存在内存泄露的问题
2. map里的value跟实际的堆内存地址存在着强引用(因为只有这一个引用，所以只能用强引用)，此时存在从current thread连过来的强引用，即此时的value还是无法被回收，除非线程结束

总结

• 当某个线程的某个threadlocal用完了，马上调用threadlocal的remove方法，就完事
• 如果线程可以及时gc，该泄露问题不大，即泄露时间只在threadlocal最后使用到线程销毁这段时间
• 但是如果线程不会GC(如线程池)，而分配者不再调用get、set方法，此时就严重内存泄漏