vol18plus ThreadLocalMap

最新推荐文章于 2024-08-12 18:40:23 发布

qq_43641886

最新推荐文章于 2024-08-12 18:40:23 发布

阅读量150

点赞数

分类专栏：并发面试

本文链接：https://blog.csdn.net/qq_43641886/article/details/106320966

版权

面试同时被 2 个专栏收录

38 篇文章 0 订阅

订阅专栏

并发

11 篇文章 0 订阅

订阅专栏

在这里插入图片描述

里面有一个entry数组实现了弱引用类，他的键就为弱引用

 static class ThreadLocalMap {

        //里面有一个entry数组实现了弱引用类，他的键就为弱引用
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
                /**默认大小为2的幂次
         * The initial capacity -- MUST be a power of two.
         */
        private static final int INITIAL_CAPACITY = 16;
        /**
        
         * Set the resize threshold to maintain at worst a 2/3 load factor.
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

默认数组大小为16，大小为2的幂次
扩容门槛为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);
        }

ThreadLocalMap构造数组是延迟加载，在插入第一个元素的时候创建对象，先取hash值，然后定位，最后在指定的桶创建对象，size=1,设置门槛

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

set方法采取了开放寻址法的线性寻址方式
首先定位到桶的位置，然后看当前位置的key是否一样，如果一样则替换，返回
如果当前key==null,则调用replaceStaleEntry(key, value, i);进行回收，并创建对象，向后遍历时，如果碰到的桶为null，则跳出循环，创建对象，size++;
然后利用if (!cleanSomeSlots(i, sz) && sz >= threshold)进行清理，如果

private void set(ThreadLocal<?> key, Object value){
	// We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

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

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

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    / If key not found, put new entry in stale slot
    //如果在查找过程中没有找到可以覆盖的entry，则将新的entry插入在脏entry
// tab[staleSlot].value = null;
//tab[staleSlot] = new Entry(key, value);
                    return;
                }
            }

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


}

rehash方法，首先利用expungeStaleEntries清理，清理以后在判断是否超标，然后用resize扩容

private void rehash() {
            expungeStaleEntries();

            // Use lower threshold for doubling to avoid hysteresis
            if (size >= threshold - threshold / 4)
                resize();
        }

resize方法扩容为原来的两倍，扩容的同时判断，key是否为null，进行回收

 /**
         * Double the capacity of the table.
         */
        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);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);
            size = count;
            table = newTab;
        }

remove方法，遍历整个数组，回收

       /**
         * Remove the entry for key.
         */
        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();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

cleanSomeSlots方法

   * @return true if any stale entries have been removed.
         */
        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;
        }

该方法逻辑请看注释（第1,2,3步），主要做了这么几件事情：
expungeStaleEntry
清理当前脏entry，即将其value引用置为null，并且将table[staleSlot]也置为null。value置为null后该value域变为不可达，在下一次gc的时候就会被回收掉，同时table[staleSlot]为null后以便于存放新的entry;
从当前staleSlot位置向后环形（nextIndex）继续搜索，直到遇到哈希桶（tab[i]）为null的时候退出；
若在搜索过程再次遇到脏entry，继续将其清除。

replaceStaleEntry方法
首先向前遍历找到第一个脏数据，如果没有的话slotToExpunge = staleSlot;
然后向后遍历匹配Key值，如果匹配，就把staleSlot结点和i交换位置
//如果在查找过程中还未发现脏entry，那么就以当前位置作为cleanSomeSlots
//的起点
//如果向前未搜索到脏entry，则在查找过程遇到脏entry的话，后面就以此时这个位置
//作为起点执行cleanSomeSlots
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
// If key not found, put new entry in stale slot
//如果在查找过程中没有找到可以覆盖的entry，则将新的entry插入在脏entry
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// If there are any other stale entries in run, expunge them
if (slotToExpunge != staleSlot)
//执行cleanSomeSlots
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);