ThreadLocal源码分析。

﹏ヽ暗。殇╰゛Y 2024-02-19 15:23 67阅读 0赞

public class ThreadLocal<T> {
    	/*
    	 * threadlocal依赖于每个线程连接到每个线程的线性探测散列映射。
    	 * ThreadLocal对象充当键，通过threadLocalHashCode进行搜索。
    	 * 这是一个自定义的哈希码(只在ThreadLocalMaps中有用)，
    	 * 它可以在相同线程使用连续构造的线程局部变量的常见情况下消除冲突，
    	 * 在不太常见的情况下保持良好的行为。
    	 */
        private final int threadLocalHashCode = nextHashCode();
    
    	// 下一个要给出的哈希码。自动更新，从零开始
        private static AtomicInteger nextHashCode =
            new AtomicInteger();
    	/*
    	 *  生成hash code间隙为这个魔数，可以让生成出来的值或者说ThreadLocal的ID较为均匀地分布在2的幂大小的数组中。
    	 */
        private static final int HASH_INCREMENT = 0x61c88647;
    	/**
    	 * 返回下一个哈希码。
    	 * @return
    	 */
        private static int nextHashCode() {
            // 以原子方式将给定值添加到HASH_INCREMENT。
            return nextHashCode.getAndAdd(HASH_INCREMENT);
        }
        /**
         * 返回此线程局部变量的当前线程的“初始值”。
         * 线程第一次使用 get() 方法访问变量时将调用此方法，
         * 但如果线程之前调用了 set(T) 方法，
         * 则不会对该线程再调用 initialValue 方法。
         * 通常，此方法对每个线程最多调用一次，
         * 但如果在调用 get() 后又调用了 remove()，则可能再次调用此方法。 
         * 该实现返回 null；如果程序员希望线程局部变量具有 null 以外的值，
         * 则必须为 ThreadLocal 创建子类，并重写此方法。
         * 通常将使用匿名内部类完成此操作
         * @return	返回此线程局部变量的初始值
         */
        protected T initialValue() {
            return null;
        }
        /**
         * 创建线程本地变量。
         * 变量的初始值是通过调用Supplier类上的get()方法确定的。
         * @param supplier	用于确定初始值的Supplier类对象
         * @return	一个新的线程局部变量
         */
        public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
            return new SuppliedThreadLocal<>(supplier);
        }
        /**
         * 创建一个线程本地变量
         */
        public ThreadLocal() {
        }
        /**
         * 返回此线程局部变量的当前线程副本中的值。
         * 如果变量没有用于当前线程的值，
         * 则先将其初始化为调用 initialValue() 方法返回的值。 
         * @return	此线程局部变量的当前线程的值
         */
        public T get() {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);// 获取与该线程相关的ThreadLocalMap。
            if (map != null) {// 非空
                ThreadLocalMap.Entry e = map.getEntry(this);// 获取与键关联的Entry。
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    T result = (T)e.value;
                    return result;
                }
            }
            return setInitialValue();
        }
        /**
         * 初始化当前线程的值
         * @return	初始值
         */
        private T setInitialValue() {
            T value = initialValue();
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);// 获取与该线程相关的ThreadLocalMap。
            if (map != null)
                map.set(this, value);
            else
                createMap(t, value);// 创建与ThreadLocal关联的ThreadLocalMap
            return value;
        }
        /**
         * 将此线程局部变量的当前线程副本中的值设置为指定值。
         * 大部分子类不需要重写此方法，它们只依靠 initialValue() 方法来设置线程局部变量的值。 
         * @param value	存储在此线程局部变量的当前线程副本中的值。
         */
        public void set(T value) {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);// 获取与该线程相关的ThreadLocalMap。
            if (map != null)
                map.set(this, value);
            else
                createMap(t, value);// 创建与ThreadLocal关联的ThreadLocalMap
        }
        /**
         * 移除此线程局部变量当前线程的值。
         * 如果此线程局部变量随后被当前线程读取，
         * 且这期间当前线程没有设置其值，
         * 则将调用其 initialValue() 方法重新初始化其值。
         * 这将导致在当前线程多次调用 initialValue 方法。 
         */
         public void remove() {
             ThreadLocalMap m = getMap(Thread.currentThread());// 获取与该线程相关的ThreadLocalMap。
             if (m != null)
                 m.remove(this);
         }
        /**
         * 获取与该线程相关的ThreadLocalMap。
         * @param t	当前线程
         * @return
         */
        ThreadLocalMap getMap(Thread t) {
            return t.threadLocals;
        }
        /**
         * 创建与ThreadLocal关联的ThreadLocalMap
         * @param t	当前线程
         * @param firstValue	map的初始entry的值
         */
        void createMap(Thread t, T firstValue) {
            t.threadLocals = new ThreadLocalMap(this, firstValue);
        }
        /**
         * 创建继承线程局部变量映射的工厂方法。
         * 设计为仅从线程构造函数调用。
         * @param parentMap	与父线程关联的map
         * @return	包含父类的可继承绑定
         */
        static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
            return new ThreadLocalMap(parentMap);
        }
        /**
         * 方法childValue在子类InheritableThreadLocal中有明确的定义，
         * 但是为了提供createInheritedMap工厂方法而在这里进行内部定义，
         * 而不需要在InheritableThreadLocal中子类化map类。
         * 这种技术比在方法中嵌入instanceof测试更好。
         * @param parentValue
         * @return
         */
        T childValue(T parentValue) {
            throw new UnsupportedOperationException();
        }
        /**
         *ThreadLocal的扩展，它从指定的Supplier获取初始值。
         * @param <T>
         */
        static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
    
            private final Supplier<? extends T> supplier;
    
            SuppliedThreadLocal(Supplier<? extends T> supplier) {
                this.supplier = Objects.requireNonNull(supplier);
            }
    
            @Override
            protected T initialValue() {
                return supplier.get();
            }
        }
        /**
         * ThreadLocalMap是一个定制的哈希映射，只适合维护线程本地值。
         * 在ThreadLocal类之外不导出任何操作。
         * 类是包私有的，允许在类线程中声明字段。
         * 为了帮助处理非常大和长期的使用，
         * 哈希表项对键使用弱引用。
         * 但是，由于没有使用引用队列，
         * 只有当表开始耗尽空间时，才保证删除过时的条目。
         */
        static class ThreadLocalMap {
            /**
             * 这个哈希映射中的项扩展了WeakReference，
             * 使用它的main ref字段作为键(它始终是一个ThreadLocal对象)。
             * 注意，null键(即enter .get() == null)表示该key不再被引用，
             * 因此可以从表中删除entry。
             * 在接下来的代码中，这些entry被称为“陈旧entries”。
             */
            static class Entry extends WeakReference<ThreadLocal<?>> {
                /** The value associated with this ThreadLocal. */
                Object value;
    
                Entry(ThreadLocal<?> k, Object v) {
                    super(k);
                    value = v;
                }
            }
            /**
             * 初始容量必须是2的幂。
             */
            private static final int INITIAL_CAPACITY = 16;
            /**
             * 根据需要调整表的大小。表的长度必须总是2的幂。
             */
            private Entry[] table;
            /**
             * 表中的entries数。
             */
            private int size = 0;
            /**
             * 要调整大小的下一个大小值。
             */
            private int threshold; // Default to 0
            /**
             * 设置大小阈值以在最坏情况下保持2/3的负载系数。
             */
            private void setThreshold(int len) {
                threshold = len * 2 / 3;
            }
            /**
             * 计算下一个索引，hash算法定位失败的时候（也就是该索引位置存在元素）
             */
            private static int nextIndex(int i, int len) {
                return ((i + 1 < len) ? i + 1 : 0);
            }
            /**
             * 上一个位置索引，hash算法定位失败的时候（也就是该索引位置存在元素）
             */
            private static int prevIndex(int i, int len) {
                return ((i - 1 >= 0) ? i - 1 : len - 1);
            }
            /**
             * 首先构造一个包含(firstKey, firstValue)的新映射。
             * threadlocalmap是惰性（lazily）构造的，
             * 所以我们只有当我们有至少一个entry要放入时才会创建一个。
             */
            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);
            }
            /**
             * 构造一个新的映射，
             * 其中包括来自给定父映射的所有可继承线程局部变量。
             * 只能由createInheritedMap调用。
             *
             * @param 与父线程关联的映射
             */
            private ThreadLocalMap(ThreadLocalMap parentMap) {
                Entry[] parentTable = parentMap.table;
                int len = parentTable.length;
                // 设置大小阈值以在最坏情况下保持2/3的负载系数
                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)
                                // 计算下一个索引，hash算法定位失败的时候（也就是该索引位置存在元素）
                                h = nextIndex(h, len);
                            table[h] = c;
                            size++;
                        }
                    }
                }
            }
            /**
             * 获取与键关联的entry。
             * 该方法本身只处理快速路径:直接命中现有key。
             * 否则，它将在错过后继续传递。
             * 这是为了最大化直接命中的性能，
             * 在某种程度上，这使得这种方法很容易实现。
    
             *
             * @param  将线程本地对象作为关键字
             * @return 与key关联的entry，如果没有键则为null
             */
            private Entry getEntry(ThreadLocal<?> key) {
                // 根据key这个ThreadLocal的ID来获取索引，也即哈希值
                int i = key.threadLocalHashCode & (table.length - 1);
                Entry e = table[i];
                // 对应的entry存在且未失效且弱引用指向的ThreadLocal就是key，则命中返回 
                if (e != null && e.get() == key)
                    return e;
                else
                	// 因为用的是线性探测，所以往后找还是有可能能够找到目标Entry的。
                    return getEntryAfterMiss(key, i, e);
            }
            /**
             * 当根据key值没有找到直接命中的entry处理方法
             *
             * @param  key 线程本地对象
             * @param  i key的哈希码的表索引
             * @param  e 表[i]的entry
             * @return 与键关联的entry，如果没有键则为null
             */
            private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
                Entry[] tab = table;
                int len = tab.length;
                // 基于线性探测法不断向后探测直到遇到空entry。
                while (e != null) {
                	// 获取此引用对象的指示对象。如果此引用对象已经由程序或垃圾回收器清除，则此方法将返回 null。
                    ThreadLocal<?> k = e.get();
                    if (k == key)
                        return e;
                    if (k == null)
                        // 该entry对应的ThreadLocal已经被回收，调用expungeStaleEntry来清理无效的entry
                        expungeStaleEntry(i);
                    else
                        // 环形意义下往后面走
                        i = nextIndex(i, len);
                    e = tab[i];
                }
                return null;
            }
            /**
             *设置与key关联的值
             *
             * @param key 线程本地对象
             * @param value 要设置的值
             */
            private void set(ThreadLocal<?> key, Object value) {
                /*
                 * 我们不像使用get()那样使用快速路径，
                 * 因为使用set()创建新entry至少和使用set()替换现有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)]) {
                    ThreadLocal<?> k = e.get();
                 // 找到对应的entry
                    if (k == key) {
                        e.value = value;
                        return;
                    }
                 // 替换失效的entry
                    if (k == null) {
                        replaceStaleEntry(key, value, i);
                        return;
                    }
                }
    
                tab[i] = new Entry(key, value);
                int sz = ++size;
                if (!cleanSomeSlots(i, sz) && sz >= threshold)
                    rehash();
            }
            /**
             * 删除key的entry.
             */
            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();
                        // 清理entry
                        expungeStaleEntry(i);
                        return;
                    }
                }
            }
            /**
             * 用指定key的entry替换在set操作期间遇到的过时entry。
             * value参数中传递的value存储在entry中，
             * 指定key的entry是否已经存在。
             *
             * 作为副作用，
             * 此方法删除包含陈旧entry的“运行时”中的所有陈旧entry。
             * (一个运行时是两个null slots之间的entry序列。)
             *
             * @param  key key值
             * @param  value 与key关联的值
             * @param  staleSlot 搜索key时遇到的第一个陈旧entry的索引。
             */
            private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                           int staleSlot) {
                Entry[] tab = table;
                int len = tab.length;
                Entry e;
                // 向前扫描，查找最前的一个无效slot
                int slotToExpunge = staleSlot;
                for (int i = prevIndex(staleSlot, len);
                     (e = tab[i]) != null;
                     i = prevIndex(i, len))
                    if (e.get() == null)
                        slotToExpunge = i;
                // 向后遍历table
                for (int i = nextIndex(staleSlot, len);
                     (e = tab[i]) != null;
                     i = nextIndex(i, len)) {
                    ThreadLocal<?> k = e.get();
                    // 找到了key，将其与无效的slot交换
                    if (k == key) {
                    	// 更新对应slot的value值
                        e.value = value;
    
                        tab[i] = tab[staleSlot];
                        tab[staleSlot] = e;
    
                        /*
                         * 如果在整个扫描过程中（包括函数一开始的向前扫描与i之前的向后扫描）
                         * 找到了之前的无效slot则以那个位置作为清理的起点，
                         * 否则则以当前的i作为清理起点
                         */
                        if (slotToExpunge == staleSlot)
                            slotToExpunge = i;
    	                 // 从slotToExpunge开始做一次连续段的清理，再做一次启发式清理
                        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                        return;
                    }
                    // 如果当前的slot已经无效，并且向前扫描过程中没有无效slot，则更新slotToExpunge为当前位置
                    if (k == null && slotToExpunge == staleSlot)
                        slotToExpunge = i;
                }
                // 如果key在table中不存在，则在原地放一个即可
                tab[staleSlot].value = null;
                tab[staleSlot] = new Entry(key, value);
    
                // 在探测过程中如果发现任何无效slot，则做一次清理（连续段清理+启发式清理）
                if (slotToExpunge != staleSlot)
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            }
            /**
             * 这个函数是ThreadLocal中核心清理函数，它做的事情很简单：
             * 就是从staleSlot开始遍历，将无效（弱引用指向对象被回收）清理，
             * 即对应entry中的value置为null，将指向这个entry的table[i]置为null，直到扫到空entry。
             * 另外，在过程中还会对非空的entry作rehash。
             * 可以说这个函数的作用就是从staleSlot开始清理连续段中的slot（断开强引用，rehash slot等）
             *
             * @param 已知具有null key的slot的staleSlot索引
             * @return stallot之后的下一个空slot的索引(在staleSlot和这个slot之间将会被检查以进行扩展)。
             */
            private int expungeStaleEntry(int staleSlot) {
                Entry[] tab = table;
                int len = tab.length;
    
                // 因为entry对应的ThreadLocal已经被回收，value设为null，显式断开强引用
                tab[staleSlot].value = null;
                // 显式设置该entry为null，以便垃圾回收
                tab[staleSlot] = null;
                size--;
    
                // 重复，直到我们遇到null
                Entry e;
                int i;
                for (i = nextIndex(staleSlot, len);
                     (e = tab[i]) != null;
                     i = nextIndex(i, len)) {
                    ThreadLocal<?> k = e.get();
                 // 清理对应ThreadLocal已经被回收的entry
                    if (k == null) {
                        e.value = null;
                        tab[i] = null;
                        size--;
                    } else {
                       /*
                        * 对于还没有被回收的情况，需要做一次rehash。
                        * 
                        * 如果对应的ThreadLocal的ID对len取模出来的索引h不为当前位置i，
                        * 则从h向后线性探测到第一个空的slot，把当前的entry给挪过去。
                        */
                        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.
                             *
                             * 这段话提及了Knuth高德纳的著作TAOCP（《计算机程序设计艺术》）的6.4章节（散列）
                             * 中的R算法。R算法描述了如何从使用线性探测的散列表中删除一个元素。
                             * R算法维护了一个上次删除元素的index，当在非空连续段中扫到某个entry的哈希值取模后的索引
                             * 还没有遍历到时，会将该entry挪到index那个位置，并更新当前位置为新的index，
                             * 继续向后扫描直到遇到空的entry。
                             *
                             * ThreadLocalMap因为使用了弱引用，所以其实每个slot的状态有三种也即
                             * 有效（value未回收），无效（value已回收），空（entry==null）。
                             * 正是因为ThreadLocalMap的entry有三种状态，所以不能完全套高德纳原书的R算法。
                             *
                             * 因为expungeStaleEntry函数在扫描过程中还会对无效slot清理将之转为空slot，
                             * 如果直接套用R算法，可能会出现具有相同哈希值的entry之间断开（中间有空entry）。
                             */
                            while (tab[h] != null)
                                h = nextIndex(h, len);
                            tab[h] = e;
                        }
                    }
                }
             // 返回staleSlot之后第一个空的slot索引
                return i;
            }
            /**
             * 启发式地清理slot,
             * i对应entry是非无效（指向的ThreadLocal没被回收，或者entry本身为空）
             * n是用于控制控制扫描次数的
             * 正常情况下如果log n次扫描没有发现无效slot，函数就结束了
             * 但是如果发现了无效的slot，将n置为table的长度len，做一次连续段的清理
             * 再从下一个空的slot开始继续扫描
             * 这个函数有两处地方会被调用，一处是插入的时候可能会被调用，另外个是在替换无效slot的时候可能会被调用，
             * 区别是前者传入的n为元素个数，后者为table的容量 
             * @param i
             * @param n
             * @return
             */
            private boolean cleanSomeSlots(int i, int n) {
                boolean removed = false;
                Entry[] tab = table;
                int len = tab.length;
                do {
                	// i在任何情况下自己都不会是一个无效slot，所以从下一个开始判断
                    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;
            }
            /**
             * 重新打包和/或重新调整表的大小。
             * 首先扫描整个表，删除过时的entry。
             * 如果这没有充分缩小表的大小，则将表的大小加倍。
             */
            private void rehash() {
            	// 做一次全量清理
                expungeStaleEntries();
    
                /*
                 * 因为做了一次清理，所以size很可能会变小。
                 * ThreadLocalMap这里的实现是调低阈值来判断是否需要扩容，
                 * threshold默认为len*2/3，所以这里的threshold - threshold / 4相当于len/2
                 */
                if (size >= threshold - threshold / 4)
                    resize();
            }
            /**
             * 扩容，因为需要保证table的容量len为2的幂，所以扩容即扩大2倍
             */
            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; // 显示设置为null
                        } else {
                        	 // 线性探测来存放Entry
                            int h = k.threadLocalHashCode & (newLen - 1);
                            while (newTab[h] != null)
                                h = nextIndex(h, newLen);
                            newTab[h] = e;
                            count++;
                        }
                    }
                }
                // 设置大小阈值以在最坏情况下保持2/3的负载系数。
                setThreshold(newLen);
                size = count;
                table = newTab;
            }
            /**
             * 删除表中所有陈旧的entry
             */
            private void expungeStaleEntries() {
                Entry[] tab = table;
                int len = tab.length;
                for (int j = 0; j < len; j++) {
                    Entry e = tab[j];
                    if (e != null && e.get() == null)
                    	// 清理entry
                        expungeStaleEntry(j);
                }
            }
        }
    }

参考：jdk 1.6 API

[https://www.cnblogs.com/micrari/p/6790229.html][https_www.cnblogs.com_micrari_p_6790229.html]

[https_www.cnblogs.com_micrari_p_6790229.html]: https://www.cnblogs.com/micrari/p/6790229.html