static class ThreadLocalMap {
    // 弱引用,在資源緊張的時(shí)候可以回收部分不再引用的ThreadLocal變量
    static class Entry extends WeakReference<ThreadLocal<?>> {
        // 當(dāng)前ThreadLocal對(duì)象所維護(hù)的數(shù)據(jù)
        Object value;
 
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    // 省略其他代碼
}

public class FastThreadLocal<V> {
    // FastThreadLocal中的index是記錄了該它維護(hù)的數(shù)據(jù)應(yīng)該存儲(chǔ)的位置
    // InternalThreadLocalMap數(shù)組中的下標(biāo), 它是在構(gòu)造函數(shù)中確定的
    private final int index;
 
    public InternalThreadLocal() {
        index = InternalThreadLocalMap.nextVariableIndex();
    }
    // 省略其他代碼
}

public final class InternalThreadLocalMap extends UnpaddedInternalThreadLocalMap {
    // 自增索引, ?于計(jì)算下次存儲(chǔ)到Object數(shù)組中的位置
    private static final AtomicInteger nextIndex = new AtomicInteger();
    private static final int ARRAY_LIST_CAPACITY_MAX_SIZE = Integer.MAX_VALUE - 8;
    public static int nextVariableIndex() {
        int index = nextIndex.getAndIncrement();
        if (index >= ARRAY_LIST_CAPACITY_MAX_SIZE || index < 0) {
            nextIndex.set(ARRAY_LIST_CAPACITY_MAX_SIZE);
            throw new IllegalStateException("too many thread-local indexed variables");
        }
        return index;
    }
    // 省略其他代碼
}

public class FastThreadLocal<V> {
    // FastThreadLocal中的index是記錄了該它維護(hù)的數(shù)據(jù)應(yīng)該存儲(chǔ)的位置
    private final int index;
 
    public final V get() {
        // 獲取當(dāng)前線程的InternalThreadLocalMap
        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
        // 根據(jù)當(dāng)前線程的index從InternalThreadLocalMap中獲取其綁定的數(shù)據(jù)
        Object v = threadLocalMap.indexedVariable(index);
        // 如果獲取當(dāng)前線程綁定的數(shù)據(jù)不為缺省值UNSET，則直接返回；否則進(jìn)行初始化
        if (v != InternalThreadLocalMap.UNSET) {
            return (V) v;
        }
 
        return initialize(threadLocalMap);
    }
    // 省略其他代碼
}

public final class InternalThreadLocalMap extends UnpaddedInternalThreadLocalMap {
    private static final int INDEXED_VARIABLE_TABLE_INITIAL_SIZE = 32;
    // 未賦值的Object變量（缺省值），當(dāng)?個(gè)與線程綁定的值被刪除之后，會(huì)被設(shè)置為UNSET
    public static final Object UNSET = new Object();
    // 存儲(chǔ)綁定到當(dāng)前線程的數(shù)據(jù)的數(shù)組
    private Object[] indexedVariables;
    // slowThreadLocalMap為JDK ThreadLocal存儲(chǔ)InternalThreadLocalMap
    private static final ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap =
            new ThreadLocal<InternalThreadLocalMap>();
    // 從綁定到當(dāng)前線程的數(shù)據(jù)的數(shù)組中取出index位置的元素
    public Object indexedVariable(int index) {
        Object[] lookup = indexedVariables;
        return index < lookup.length? lookup[index] : UNSET;
    }
    public static InternalThreadLocalMap get() {
        Thread thread = Thread.currentThread();
        // 判斷當(dāng)前線程是否是FastThreadLocalThread類型
        if (thread instanceof FastThreadLocalThread) {
            return fastGet((FastThreadLocalThread) thread);
        } else {
            return slowGet();
        }
    }
    private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
        // 直接獲取當(dāng)前線程的InternalThreadLocalMap
        InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
        // 如果當(dāng)前線程的InternalThreadLocalMap還未創(chuàng)建，則創(chuàng)建并賦值
        if (threadLocalMap == null) {
            thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
        }
        return threadLocalMap;
    }
    private static InternalThreadLocalMap slowGet() {
        // 使用JDK ThreadLocal獲取InternalThreadLocalMap
        InternalThreadLocalMap ret = slowThreadLocalMap.get();
        if (ret == null) {
            ret = new InternalThreadLocalMap();
            slowThreadLocalMap.set(ret);
        }
        return ret;
    }
    private InternalThreadLocalMap() {
        indexedVariables = newIndexedVariableTable();
    }
    // 初始化一個(gè)32位長度的Object數(shù)組，并將其元素全部設(shè)置為缺省值UNSET
    private static Object[] newIndexedVariableTable() {
        Object[] array = new Object[INDEXED_VARIABLE_TABLE_INITIAL_SIZE];
        Arrays.fill(array, UNSET);
        return array;
    }
    // 省略其他代碼
}

public class FastThreadLocal<V> {
    // FastThreadLocal初始化時(shí)variablesToRemoveIndex被賦值為0
    private static final int variablesToRemoveIndex = InternalThreadLocalMap.nextVariableIndex();
    public final void set(V value) {
        // 判斷value值是否是未賦值的Object變量（缺省值）
        if (value != InternalThreadLocalMap.UNSET) {
            // 獲取當(dāng)前線程對(duì)應(yīng)的InternalThreadLocalMap
            InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
            // 將InternalThreadLocalMap中數(shù)據(jù)替換為新的value
            // 并將FastThreadLocal對(duì)象保存到待清理的Set中
            setKnownNotUnset(threadLocalMap, value);
        } else {
            remove();
        }
    }
    private void setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value) {
        // 將InternalThreadLocalMap中數(shù)據(jù)替換為新的value
        if (threadLocalMap.setIndexedVariable(index, value)) {
            // 并將當(dāng)前的FastThreadLocal對(duì)象保存到待清理的Set中
            addToVariablesToRemove(threadLocalMap, this);
        }
    }
    private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
        // 取下標(biāo)index為0的數(shù)據(jù)，用于存儲(chǔ)待清理的FastThreadLocal對(duì)象Set集合中
        Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
        Set<FastThreadLocal<?>> variablesToRemove;
        if (v == InternalThreadLocalMap.UNSET || v == null) {
            // 下標(biāo)index為0的數(shù)據(jù)為空，則創(chuàng)建FastThreadLocal對(duì)象Set集合
            variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());
            // 將InternalThreadLocalMap中下標(biāo)為0的數(shù)據(jù)，設(shè)置成FastThreadLocal對(duì)象Set集合
            threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove);
        } else {
            variablesToRemove = (Set<FastThreadLocal<?>>) v;
        }
        // 將FastThreadLocal對(duì)象保存到待清理的Set中
        variablesToRemove.add(variable);
    }
    // 省略其他代碼
}

public final class InternalThreadLocalMap extends UnpaddedInternalThreadLocalMap {
    // 未賦值的Object變量（缺省值），當(dāng)?個(gè)與線程綁定的值被刪除之后，會(huì)被設(shè)置為UNSET
    public static final Object UNSET = new Object();
    // 存儲(chǔ)綁定到當(dāng)前線程的數(shù)據(jù)的數(shù)組
    private Object[] indexedVariables;
    // 綁定到當(dāng)前線程的數(shù)據(jù)的數(shù)組能再次采用x2擴(kuò)容的最大量
    private static final int ARRAY_LIST_CAPACITY_EXPAND_THRESHOLD = 1 << 30;
    private static final int ARRAY_LIST_CAPACITY_MAX_SIZE = Integer.MAX_VALUE - 8;
    // 將InternalThreadLocalMap中數(shù)據(jù)替換為新的value
    public boolean setIndexedVariable(int index, Object value) {
        Object[] lookup = indexedVariables;
        if (index < lookup.length) {
            Object oldValue = lookup[index];
            // 直接將數(shù)組 index 位置設(shè)置為 value，時(shí)間復(fù)雜度為 O(1)
            lookup[index] = value;
            return oldValue == UNSET;
        } else { // 綁定到當(dāng)前線程的數(shù)據(jù)的數(shù)組需要擴(kuò)容，則擴(kuò)容數(shù)組并數(shù)組設(shè)置新value
            expandIndexedVariableTableAndSet(index, value);
            return true;
        }
    }
    private void expandIndexedVariableTableAndSet(int index, Object value) {
        Object[] oldArray = indexedVariables;
        final int oldCapacity = oldArray.length;
        int newCapacity;
        // 判斷可進(jìn)行x2方式進(jìn)行擴(kuò)容
        if (index < ARRAY_LIST_CAPACITY_EXPAND_THRESHOLD) {
            newCapacity = index;
            // 位操作，提升擴(kuò)容效率
            newCapacity |= newCapacity >>>  1;
            newCapacity |= newCapacity >>>  2;
            newCapacity |= newCapacity >>>  4;
            newCapacity |= newCapacity >>>  8;
            newCapacity |= newCapacity >>> 16;
            newCapacity ++;
        } else { // 不支持x2方式擴(kuò)容，則設(shè)置綁定到當(dāng)前線程的數(shù)據(jù)的數(shù)組容量為最大值
            newCapacity = ARRAY_LIST_CAPACITY_MAX_SIZE;
        }
        // 按擴(kuò)容后的大小創(chuàng)建新數(shù)組，并將老數(shù)組數(shù)據(jù)copy到新數(shù)組
        Object[] newArray = Arrays.copyOf(oldArray, newCapacity);
        // 新數(shù)組擴(kuò)容后的部分賦UNSET缺省值
        Arrays.fill(newArray, oldCapacity, newArray.length, UNSET);
        // 新數(shù)組的index位置替換成新的value
        newArray[index] = value;
        // 綁定到當(dāng)前線程的數(shù)據(jù)的數(shù)組用新數(shù)組替換
        indexedVariables = newArray;
    }
    // 省略其他代碼
}

public class FastThreadLocal<V> {
    // FastThreadLocal初始化時(shí)variablesToRemoveIndex被賦值為0
    private static final int variablesToRemoveIndex = InternalThreadLocalMap.nextVariableIndex();
    public final void remove() {
        // 獲取當(dāng)前線程的InternalThreadLocalMap
        // 刪除當(dāng)前的FastThreadLocal對(duì)象及其維護(hù)的數(shù)據(jù)
        remove(InternalThreadLocalMap.getIfSet());
    }
    public final void remove(InternalThreadLocalMap threadLocalMap) {
        if (threadLocalMap == null) {
            return;
        }
        // 根據(jù)當(dāng)前線程的index，并將該數(shù)組下標(biāo)index位置對(duì)應(yīng)的值設(shè)置為缺省值UNSET
        Object v = threadLocalMap.removeIndexedVariable(index);
        // 存儲(chǔ)待清理的FastThreadLocal對(duì)象Set集合中刪除當(dāng)前FastThreadLocal對(duì)象
        removeFromVariablesToRemove(threadLocalMap, this);
        if (v != InternalThreadLocalMap.UNSET) {
            try {
                // 空方法，用戶可以繼承實(shí)現(xiàn)
                onRemoval((V) v);
            } catch (Exception e) {
                PlatformDependent.throwException(e);
            }
        }
    }
    public static void removeAll() {
        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.getIfSet();
        if (threadLocalMap == null) {
            return;
        }
        try {
            // 取下標(biāo)index為0的數(shù)據(jù)，用于存儲(chǔ)待清理的FastThreadLocal對(duì)象Set集合中
            Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
            if (v != null && v != InternalThreadLocalMap.UNSET) {
                @SuppressWarnings("unchecked")
                Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
                // 遍歷所有的FastThreadLocal對(duì)象并刪除它們以及它們維護(hù)的數(shù)據(jù)
                FastThreadLocal<?>[] variablesToRemoveArray =
                        variablesToRemove.toArray(new FastThreadLocal[0]);
                for (FastThreadLocal<?> tlv: variablesToRemoveArray) {
                    tlv.remove(threadLocalMap);
                }
            }
        } finally {
            // 刪除InternalThreadLocalMap中threadLocalMap和slowThreadLocalMap數(shù)據(jù)
            InternalThreadLocalMap.remove();
        }
    }
    private static void removeFromVariablesToRemove(
            InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
        // 取下標(biāo)index為0的數(shù)據(jù)，用于存儲(chǔ)待清理的FastThreadLocal對(duì)象Set集合中
        Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
        if (v == InternalThreadLocalMap.UNSET || v == null) {
            return;
        }
        @SuppressWarnings("unchecked")
        // 存儲(chǔ)待清理的FastThreadLocal對(duì)象Set集合中刪除該FastThreadLocal對(duì)象
        Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
        variablesToRemove.remove(variable);
    }
    // 省略其他代碼
}

public final class InternalThreadLocalMap extends UnpaddedInternalThreadLocalMap {
    // 根據(jù)當(dāng)前線程獲取InternalThreadLocalMap
       public static InternalThreadLocalMap getIfSet() {
        Thread thread = Thread.currentThread();
        if (thread instanceof FastThreadLocalThread) {
            return ((FastThreadLocalThread) thread).threadLocalMap();
        }
        return slowThreadLocalMap.get();
    }
    // 數(shù)組下標(biāo)index位置對(duì)應(yīng)的值設(shè)置為缺省值UNSET
    public Object removeIndexedVariable(int index) {
        Object[] lookup = indexedVariables;
        if (index < lookup.length) {
            Object v = lookup[index];
            lookup[index] = UNSET;
            return v;
        } else {
            return UNSET;
        }
    }
    // 刪除threadLocalMap和slowThreadLocalMap數(shù)據(jù)
    public static void remove() {
        Thread thread = Thread.currentThread();
        if (thread instanceof FastThreadLocalThread) {
            ((FastThreadLocalThread) thread).setThreadLocalMap(null);
        } else {
            slowThreadLocalMap.remove();
        }
    }
    // 省略其他代碼
}