<dependency>            <groupId>io.netty</groupId>            <artifactId>netty-all</artifactId>            <version>4.1.92.Final</version>        </dependency>

 * This class provides thread-local variables.  These variables differ from * their normal counterparts in that each thread that accesses one (via its * {@code get} or {@code set} method) has its own, independently initialized * copy of the variable.  {@code ThreadLocal} instances are typically private * static fields in classes that wish to associate state with a thread (e.g., * a user ID or Transaction ID).

    public T get() {        Thread t = Thread.currentThread();      //可以看出存储结构类似一个map        ThreadLocalMap map = getMap(t);        if (map != null) {          //也是通过hash获取key，不过具体算法与HashMap有些差异，          //既然是hash，那么就要处理哈希冲突，HasjMap我们都知道是通过链式去处理的，          //而ThreadLocal是通过开放地址法的，因为作者Josh Bloch and Doug Lea认为线程变量中并不会存放太多entry          //所以使用开放地址法，一来设计更加简单，二来节约空间。不过开放地址也有自己的缺点比如删除之后需要移动entry            ThreadLocalMap.Entry e = map.getEntry(this);            if (e != null) {                @SuppressWarnings("unchecked")                T result = (T)e.value;                return result;            }        }        return setInitialValue();    }//map结构存储在Thread对象中，也就是为什么也叫做线程变量    ThreadLocalMap getMap(Thread t) {        return t.threadLocals;    }

static class ThreadLocalMap {
        /**         * The entries in this hash map extend WeakReference, using         * its main ref field as the key (which is always a         * ThreadLocal object).  Note that null keys (i.e. entry.get()         * == null) mean that the key is no longer referenced, so the         * entry can be expunged from table.  Such entries are referred to         * as "stale entries" in the code that follows.         */  //entry的对象，存储kv结构        static class Entry extends WeakReference<ThreadLocal<?>> {            /** The value associated with this ThreadLocal. */            Object value;
            Entry(ThreadLocal<?> k, Object v) {                super(k);                value = v;            }        }
        /**         * The initial capacity -- MUST be a power of two.         */        private static final int INITIAL_CAPACITY = 16;
        /**         * The table, resized as necessary.         * table.length MUST always be a power of two.         */  //使用数组存储entry        private Entry[] table;

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;  //计算index的哈希值            int i = key.threadLocalHashCode & (len-1);//遍历table，条件是Entry对象非空，也就是说，第一次插入的话，一定都是null            for (Entry e = tab[i];                 e != null;                 e = tab[i = nextIndex(i, len)]) {                ThreadLocal<?> k = e.get();//key相等则替换                if (k == key) {                    e.value = value;                    return;                }//key是空，这里就是清理的逻辑，一般来说不会走到这里，因为Threadlocal在remove的时候，//不仅会设置entry的为空，也会设置table对应的元素为空，还会做entry的移动。//这里应该就是为了处理没有调用remove，但是ThreadLocal对象空了的异常情况，大部分情况是gc导致的，//因为entry的key是WeakReference                if (k == null) {                    replaceStaleEntry(key, value, i);                    return;                }            }//没有找到替换值，或者key空的情况，正常插入            tab[i] = new Entry(key, value);            int sz = ++size;  //清理table，从i开始，长度就是table的大小，处理的就是entry非空，key（ThreadLocal）为空的情况，与  //replaceStaleEntry类似            if (!cleanSomeSlots(i, sz) && sz >= threshold)                rehash();        }

 * A special variant of {@link ThreadLocal} that yields higher access performance when accessed from a * {@link FastThreadLocalThread}. * <p> * Internally, a {@link FastThreadLocal} uses a constant index in an array, instead of using hash code and hash table, * to look for a variable.  Although seemingly very subtle, it yields slight performance advantage over using a hash * table, and it is useful when accessed frequently. * </p><p> * To take advantage of this thread-local variable, your thread must be a {@link FastThreadLocalThread} or its subtype. * By default, all threads created by {@link DefaultThreadFactory} are {@link FastThreadLocalThread} due to this reason. * </p><p> * Note that the fast path is only possible on threads that extend {@link FastThreadLocalThread}, because it requires * a special field to store the necessary state.  An access by any other kind of thread falls back to a regular * {@link ThreadLocal}. * </p>

    public FastThreadLocal() {        index = InternalThreadLocalMap.nextVariableIndex();    }

    /**     * Set the value for the current thread.     */    public final void set(V value) {        if (value != InternalThreadLocalMap.UNSET) {            InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();            setKnownNotUnset(threadLocalMap, value);        } else {            remove();        }    }//io.netty.util.internal.InternalThreadLocalMap的方法    public static InternalThreadLocalMap get() {        Thread thread = Thread.currentThread();        if (thread instanceof FastThreadLocalThread) {          //快速获取，因为FastThreadLocalThread内部就有InternalThreadLocalMap的成员变量            return fastGet((FastThreadLocalThread) thread);        } else {          //走回ThreadLocal，通过io.netty.util.internal.UnpaddedInternalThreadLocalMap#slowThreadLocalMap去获取          //这个变量就是一个ThreadLocal，也就是说netty兼容非FastThreadLocalThread的处理方式就是          //把自己fast模式下需要使用的InternalThreadLocalMap变量，使用ThreadLocal作为存储媒介，相当于做了一下中转          //其实总结一下就是如果不使用FastThreadLocalThread，那么完全多此一举            return slowGet();        }    }    /**     * @return see {@link InternalThreadLocalMap#setIndexedVariable(int, Object)}.     */    private void setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value) {      //直接数组赋值        if (threadLocalMap.setIndexedVariable(index, value)) {            addToVariablesToRemove(threadLocalMap, this);        }    }//这里就是netty的清理逻辑拉，variablesToRemoveIndex这个index跟之前说的常量index类似，他是在实例初始化的时候初始化的//对象是一个Set<FastThreadLocal<?>>。用来存放需要被清理的FastThreadLocal的对象，每次set都会加入这个set//用set方便去重，因为一个FastThreadLocal多次set就会加入多次    private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {        Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);        Set<FastThreadLocal<?>> variablesToRemove;        if (v == InternalThreadLocalMap.UNSET || v == null) {            variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());            threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove);        } else {            variablesToRemove = (Set<FastThreadLocal<?>>) v;        }
        variablesToRemove.add(variable);    }

    /**     * Removes all {@link FastThreadLocal} variables bound to the current thread.  This operation is useful when you     * are in a container environment, and you don't want to leave the thread local variables in the threads you do not     * manage.     */    public static void removeAll() {        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.getIfSet();        if (threadLocalMap == null) {            return;        }
        try {          //获取待清理的FastThreadLocal set            Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);            if (v != null && v != InternalThreadLocalMap.UNSET) {                @SuppressWarnings("unchecked")                Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;                FastThreadLocal<?>[] variablesToRemoveArray =                        variablesToRemove.toArray(new FastThreadLocal[0]);              //遍历remove                for (FastThreadLocal<?> tlv: variablesToRemoveArray) {                    tlv.remove(threadLocalMap);                }            }        } finally {            InternalThreadLocalMap.remove();        }    }

    /**     * Sets the value to uninitialized for the specified thread local map;     * a proceeding call to get() will trigger a call to initialValue().     * The specified thread local map must be for the current thread.     */    @SuppressWarnings("unchecked")    public final void remove(InternalThreadLocalMap threadLocalMap) {        if (threadLocalMap == null) {            return;        }//删除线程变量        Object v = threadLocalMap.removeIndexedVariable(index);      //把自己从待清理的FastThreadLocal set中移除        removeFromVariablesToRemove(threadLocalMap, this);
        if (v != InternalThreadLocalMap.UNSET) {            try {              //子类实现                onRemoval((V) v);            } catch (Exception e) {                PlatformDependent.throwException(e);            }        }    }

private void registerCleaner(final InternalThreadLocalMap threadLocalMap) {    Thread current = Thread.currentThread();    if (FastThreadLocalThread.willCleanupFastThreadLocals(current) ||	//线程是FastThreadLocalThread类型并且构造这个线程时传入了runnable        threadLocalMap.indexedVariable(cleanerFlagIndex) != InternalThreadLocalMap.UNSET) {	//已经注册过了        return;    }    // removeIndexedVariable(cleanerFlagIndex) isn't necessary because the finally cleanup is tied to the lifetime    // of the thread, and this Object will be discarded if the associated thread is GCed.    threadLocalMap.setIndexedVariable(cleanerFlagIndex, Boolean.TRUE);	//设置value，避免重复注册
    // We will need to ensure we will trigger remove(InternalThreadLocalMap) so everything will be released    // and FastThreadLocal.onRemoval(...) will be called.//即为 每个FastThreadLocal注册对象清理器，即线程销毁的时候，把线程的变量map清理掉    ObjectCleaner.register(current, new Runnable() {        @Override        public void run() {            remove(threadLocalMap);
            // It's fine to not call InternalThreadLocalMap.remove() here as this will only be triggered once            // the Thread is collected by GC. In this case the ThreadLocal will be gone away already.        }    });}//后台线程private static final Runnable CLEANER_TASK = new Runnable() {        @Override        public void run() {            boolean interrupted = false;            for (;;) {              //自旋条件，就是注册的AutomaticCleanerReference集合非空，              //为什么官网说不可停止，就是因为这个set不对外暴露可以清理的方法，同时集合元素AutomaticCleanerReference也不对外暴露                // Keep on processing as long as the LIVE_SET is not empty and once it becomes empty                // See if we can let this thread complete.                while (!LIVE_SET.isEmpty()) {                    final AutomaticCleanerReference reference;                    try {                      //销毁队列中获取已经被销毁的对象                        reference = (AutomaticCleanerReference) REFERENCE_QUEUE.remove(REFERENCE_QUEUE_POLL_TIMEOUT_MS);                    } catch (InterruptedException ex) {                        // Just consume and move on                        interrupted = true;                        continue;                    }                    if (reference != null) {                        try {                          //启动对象的清理线程                            reference.cleanup();                        } catch (Throwable ignored) {                            // ignore exceptions, and don't log in case the logger throws an exception, blocks, or has                            // other unexpected side effects.                        }                        LIVE_SET.remove(reference);                    }                }                CLEANER_RUNNING.set(false);
                // Its important to first access the LIVE_SET and then CLEANER_RUNNING to ensure correct                // behavior in multi-threaded environments.                if (LIVE_SET.isEmpty() || !CLEANER_RUNNING.compareAndSet(false, true)) {                    // There was nothing added after we set STARTED to false or some other cleanup Thread                    // was started already so its safe to let this Thread complete now.                    break;                }            }            if (interrupted) {                // As we caught the InterruptedException above we should mark the Thread as interrupted.                Thread.currentThread().interrupt();            }        }    };