Java8源码阅读 - ThreadLocal

有时候我们想要将某些数据和特定的线程进行关联，可以使用一个全局Map将线程id和数据做映射，当然我们还可以使用JDK提供现成的ThreadLocal来完成这个需求；

只要是启动的线程并且ThreadLocal实例是可访问的，该个线程都有一个对其线程局部变量副本的隐式引用，在一个线程退出后，它的线程本地实例的所有副本都将会被GC给回收（除非存在对这些副本的其他引用）。

ThreadLocal.ThreadLocalMap threadLocals = null;

在Thread类里面有一个threadLocalMap的引用；

ThreadLocalMap

static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    private Entry[] table;
    ... 
}

ThreadLocalMap内部使用一个Entry类型来储存key和value的映射，key为ThreadLocal对象，value为想要储存的对象，即同一个ThreadLocal对象只能对应一个value；

同时Entry使用弱引用持有ThreadLocal对象，如果ThreadLocal对象不再有任何强引用存在时，能够让GC释放Entry对象已经内部的value，避免内存泄露；

// 必须为2的幂次方
private static final int INITIAL_CAPACITY = 16;
// 扩/缩容阀值
private int threshold; 

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY); // threshold为table大小的2/3
}

构造器方法初始化了table、size、threshold，有个需要注意的地方就是关于hash定位的方式；

private final int threadLocalHashCode = nextHashCode();

private static AtomicInteger nextHashCode = new AtomicInteger();

// 将隐式顺序线程本地id转换为接近最优扩散的倍增哈希值
//（为什么是这个值，网上有很多资料）
private static final int HASH_INCREMENT = 0x61c88647; 

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

在同一个ClassLoader中所有ThreadLocal都共享一个AtomicInteger#nextHashCode，所以每次调用都是在上一次的基础上自增0x61c88647，那么就意味着每个ThreadLocal对象的hashCode是不一样的；

private void set(ThreadLocal<?> key, Object value) {
    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)]) {
        // 如果出现hash碰撞
        ThreadLocal<?> k = e.get();
        if (k == key) {
            // 如果是同一个threadLocal对象，替换value
            e.value = value;
            return;
        }
        // 不是同一个对象，意味着两个threadLocal对象定位到同一个slot
        if (k == null) {
            // 如果threadLocal被GC掉了
            replaceStaleEntry(key, value, i); // replace
            return;
        }
        // 该槽被占用了，重新定位
    }
    // 该slot是空的，将entry放入槽中
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 如果有必要则进行清除工作
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash(); // 扩容
}
// 到最大长度后从0开始
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

采用开放地址法处理哈希碰撞，如果同一个槽被占用了在再次定位前，会首先判断占用槽的ThreadLocal是否被GC释放掉了，如果是会把该槽原本的entry替换成新的threadLocal；

如果没有出现hash冲突，直接将新的entry放入槽中，并且在最后都需要进行检查table是是否有陈旧的slot，如果有必要的话进行清除工作，如果都没有且当前table的大小已经到了扩容阀值，则会进行扩容操作；

替换陈旧的Entry
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
    // key：需要set的threadLocal
    // value：value
    // staleSlot：set中遇到的第一个可以被替换的槽空间
    Entry[] tab = table;
    int len = tab.length;
    Entry e;
    // 以下操作其目的还是为了尽可能的释放slot空间

    int slotToExpunge = staleSlot;
    // 从当前槽开始向前局部扫描，查询并记录需要擦除的slot，直到遇到第一个空槽
    for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = I;
    // 从staleSlot开始向后扫描，第一个元素为staleSlot+1
    for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        // 如果找到了key，那么我们需要将它与陈旧的entry交换，以维护哈希表的顺序
        if (k == key) {
            // 找到了该threadLocal对象
            e.value = value; // 直接替换value
            // 将当前threadLocal对象所在的槽的位置移到需要交换的位置
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            if (slotToExpunge == staleSlot) // 如果前面没有找到需要擦除的slots
                slotToExpunge = I;
            // 从原来threadLocal的位置开始进行清除工作
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }
        // 该槽的threadLocal对象不是调用set方法的threadLocal
        if (k == null && slotToExpunge == staleSlot)
            // k == null：意味着发现另一个可以被清空的槽
            // slotToExpunge == staleSlot：意味着在遍历过程中这是第一个被发现陈旧的槽
            slotToExpunge = I;
    }
    // 在刚刚的布局扫描中，没有发现传进来的threadLocal对象
    // 把陈旧的slot中的threadLocal对象替换成新的threadLocal
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);
    // 在刚刚的布局扫描中，发现其他陈旧的slot，进行清除工作
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

该方法把在set操作过程中遇到的可以被替换的陈旧的Entry对象，替换成新的ThreadLocal，主要是两个步骤：

  1. 进行局部扫描，查询并记录是否有需要擦除的slot；
  2. 从被替换槽的位置开始向后扫描，如果发现threadLocal对象已经存在table里面，则意味着当时在set操作添加该threadLocal时遇到了哈希冲突，于是向后寻找空间插入，现在原本的位置上的old_threadLocal对象已经被GC释放掉，那么可以把该threadLocal对象的位置移动到原本old_threadLocal的位置，两个对象hash定位到的位置是同一个，所以移动不会造成哈希表顺序混乱；
  3. 如果在table中找不到threadLocal对象，则直接将旧的Entry替换成老的Entry；
  4. 方法结束前，如果有需要都会进行清理工作；
清除工作
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    // 清除陈旧的slot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;
    // 以下操作目的是将部分槽重新哈希
    Entry e;
    int I;
    // 从当前的staleSlot开始向后遍历，直到遇到空槽
    for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {
            // 如果遇到其他threadLocal被gc的，一并释放该槽空间
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            int h = k.threadLocalHashCode & (len - 1); // 重新哈希entry
            if (h != i) {
                // 如果重哈希后是不同的位置
                tab[i] = null;
                while (tab[h] != null)
                    // 如果遇到hash冲突，再次hash
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return I;
}

该方法清除table中指定槽的空间，并且还会顺带遍历部分槽空间，如果发现有被淘汰的threadLocal也会一并把这些槽给清空，如果不需要清除，那么会尝试将它们重新hash定位，最后返回从staleSlot向后遍历时遇到的第一个空槽；

private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        // 从某个位置开始遍历扫描
        i = nextIndex(i, len);
        Entry e = tab[I];
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

扫描log2(n)个槽空间，如果发现有需要清除的slot，会执行expungeStaleEntry进行清扫，并且还会花费O(n)的时间复杂度来清理其余部分陈旧的slot，这么多操作其目的就是为了尽可能的将陈旧的slot及时清空，避免不必要的扩容操作；

扩容
private void rehash() {
    expungeStaleEntries(); // 遍历table，如果发现可回收的slot会进行回收
    if (size >= threshold - threshold / 4) 
        resize();
}
// 直接扩容成两倍大小
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1); // 重新hash
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }
    setThreshold(newLen);
    size = count;
    table = newTab;
}

在rehash操作里面再一次的检查是否有可以清理的槽，可以看到作者的意图，在非不得已的情况下才会进行扩容操作，并且扩容后是不能把容量缩小的，扩容后会对所有的元素进行重新哈希；

Get
private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[I];
    if (e != null && e.get() == key)
        // 如果hash命中，直接返回
        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) {
        // 有hash冲突
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            // threadlocal被释放了，开始清理工作
            expungeStaleEntry(i);
        else
            // 向下继续寻找
            i = nextIndex(i, len);
        e = tab[I];
    }
    return null;
}

在通常情况下会直接哈希命中获取到所对应值，但是在命中失败的情况下，如果有发现陈旧的entry，会先进行清理工作，然后重新定位直到找到或找不到value；

ThreadLocal

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

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

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

set方法将自身ThreadLocal对象作为key，然后调用ThreadLocalMap#set处理；

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;
        }
    }
    return setInitialValue();
}

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

protected T initialValue() {
    return null;
}

同样get方法也是将自身作为key到ThreadLocalMap中查找；

主要的逻辑代码差不多都看过了，整个引用关系图也就明了了；

实线为强引用，虚线为弱引用

每个线程ThreadLocalMap对象的生命周期是伴随着整个线程的生命周期，在同一个线程中，所有ThreadLocal对象操作的map都是同一个，而ThreadLocal和Thread的生命周期却没有必然的联系，所以说ThreadLocalMap内部对ThreadLocal持弱引用；

下面来看两个实例

示例1
public class ThreadLocalTest {
    public static void main(String[] args) {
        new MyThread().start();
    }

    static class MyThread extends Thread {
        ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
        @Override
        public void run() {
            for (int i = 0; i < 9; i++) {
                ThreadLocal<Integer> tmp = new ThreadLocal<>();
                tmp.set(i+100);
            }
            System.gc();
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            threadLocal.set(1);
        }
    }
}

实例一模拟的是ThreadLocal的生命周期比线程的生命周期短的场景；
在该场景下等到代码走到threadLocal.set(1);这一行时，该线程的ThreadLocalMap会有大量的Entry里面的referent是为空，因为tmp被GC回收了，然而Entry里面的Value仍然是存在强引用，如下图所示

最终会触发cleanSomeSlots进行清扫工作，将陈旧的Entry全部释放，进而释放掉Entry对Value的引用；

示例2
public class ThreadLocalTest {
    static final ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();
        new MyThread().start();
        new MyThread().start();
        System.gc();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new MyThread().start();
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            threadLocal.set(1);
        }
    }
}

第二种示例就是模拟ThreadLocal生命周期比线程生命周期长的场景，这种场景应该是比较常见的，引用关系也比较简单；

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 199,271评论 5赞 466
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 83,725评论 2赞 376
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 146,252评论 0赞 328
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 53,634评论 1赞 270
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 62,549评论 5赞 359
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 47,985评论 1赞 275
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,471评论 3赞 390
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,128评论 0赞 254
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,257评论 1赞 294
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,233评论 2赞 317
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,235评论 1赞 328
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,940评论 3赞 316
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,528评论 3赞 302
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,623评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,858评论 1赞 255
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,245评论 2赞 344
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 41,790评论 2赞 339