源码 ThreadLocal (线程私有变量)

简单介绍

ThreadLocal 是用来声明一个线程私有变量的容器。在被多个线程持有时,ThreadLocal 能保证每个线程都能拥有独一无二的实例。示例如下

public class Main {

    public static void main(String[] args) {
        BizOperator operator = new BizOperator();
        Runnable task = operator::operate;
        // 以下四个线程在执行 BizOperator::operate 时,访问到的 threadPriVar 都不一样
        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();
        new Thread(task).start();
    }

    static class BizOperator {
        ThreadLocal threadPriVar = ThreadLocal.withInitial(Object::new);

        void operate() {
            // 每个线程在这里获取到的 someVar 都不一样
            Object someVar = threadPriVar.get();
        }
    }
}

 
 

源码概览

在开始之前,先思考一个问题:这个需求如果甩在面前,自己会如何实现?简单的思路可以在 ThreadLocal 里维护一个 Map,然后去设值、取值即可。伪代码如下:

public class ThreadLocalHomeMade {
        Map threadLocalMap= new HashMap<>();

        public Object get() {
            return threadLocalMap.get(Thread.currentThread());
        }
        public void set(Object val) {
            threadLocalMap.put(Thread.currentThread(), val);
        }
    }

emm,好像不对,在 ThreadLocal 中维护了所有了访问当前变量的 Thread 引用,且不好把握释放引用的时机,这样会给垃圾回收带来难度,会造成不同程度的内存泄露。不过我们可以通过 Reference 等来缓解这个问题。

我们跟一下源码,来看下JDK是如何实现的

ThreadLocal::get 找到 ThreadLocal::getMap 找到 Thread.threadLocals 就是他了,JDK通过把所有线程私有变量存在当前线程的 threadLocals 变量中。soga,JDK是以线程维度去存储所有变量,而在我的实现中,是以单个变量的维度去存储所有线程的私有变量。

有大神曾曰,设计的根本在于数据结构。那我们来看一下 ThreadLocalMap 的实现

/*
仅从成员变量上来看,其实是一个简化版的 HashMap
*/
class ThreadLocalMap {
        // 初始容量
        private static final int INITIAL_CAPACITY = 16;
        // 数据的实际存储容器
        private Entry[] table;
        // 存储的数据总数
        private int size = 0;
        // 当size超过该值时,会对table进行扩容
        private int threshold; // Default to 0
}

我们再来看下 Entry 的源码

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

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

那其实这里和HashMap就非常之像了,ThreadLocal充当Key的角色,然后Value即是线程的私有变量。他的Hash算法:key.threadLocalHashCode & (table.length - 1)

深入一下

ThreadLocal::get

跟入源码后按照路径 ThreadLocal::get -> ThreadLocalMap::getEntry 找到第一处核心代码 ThreadLocalMap::getEntryAfterMiss,这端是在HashCode碰撞时,线性探测ThreadLocal的值

      Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            while (e != null) {
                ThreadLocal k = e.get();
                // 存在Hash碰撞,因此算出HashCode后还需要判断ThreadLocal
                if (k == key)
                    return e;
                if (k == null)
                    expungeStaleEntry(i);
                // 线性探测
                else
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
        }

然后找到第二处核心代码ThreadLocalMap::expungeStaleEntry

int expungeStaleEntry(int staleSlot) {
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    ThreadLocal.ThreadLocalMap.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;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

ThreadLocal::set

你可能感兴趣的:(源码 ThreadLocal (线程私有变量))