• 1 概述
• 2 FTL相关数据结构和类结构
  • 2.1 InternalThreadLocalMap
  • 2.2 FTL类结构
• 3 FTL数据设置或获取
  • 3.1 数据放置
  • 3.2 数据获取
• 4 清理
  • 4.1 主动清理
  • 4.2 后台线程清理
• 5 阅读源码发现的一个问题

1 概述

Netty为了提高应用性能做了许多方面的努力，本篇文章介绍其实现的其改进版的ThreadLocal实现FastThreadLocal，Netty实现的FastThreadLocal相较于Java原生优化了ThreadLocal的访问速度、内存泄漏等方面性能。

阅读过Java ThreadLocal源码的都知道其实现原理，Java的每个Thread实例都有ThreadLocal.ThreadLocalMap类型的字段threadLocals，我们使用的ThreadLocal对象实例则作为key，实际的值为value，ThreadLocalMap使用数组保存key-value，具体的数据结构是hash列表并使用线性探测再散列解决hash冲突。还有一点要注意的是上述key-value组成的Entry是WeakReference子类，所以在对ThreadLocal进行set和get时会删除被GC回收的无效Entry，在使用不当时可能会造成内存泄漏，另外使用hash列表实现的底层数据结构也具有较高的时间复杂度。

Netty实现的FastThreadLocal底层也是通过数据维护Key-value对象，与Java原生ThreadLocal使用ThreadLocal作为Key不同的是，FastThreadLocal通过保存数组下标实现了对value的快速访问。同时FastThreadLocal也实现了多种方式避免了内存泄漏问题，下面会对这些内容进行分别介绍。

为了叙述方便，下文使用FTL指代Netty的FastThreadLocal，使用TL指代Java原生ThreadLocal。

2 FTL相关数据结构和类结构

Netty为了采用FTL，在Java Thread的基础上实现了自己的FastThreadLocalThread。为了理解FTL，我们需要关注FastThreadLocalThread的两个字段cleanupFastThreadLocals和threadLocalMap，其中cleanupFastThreadLocals和FTL是否能主动清理有关，我们后面会介绍，threadLocalMap则类似JavaThread类的threadLocals，用于保存该FastThreadLocalThread持有的所有FTL数据。

2.1 InternalThreadLocalMap

FastThreadLocalThread.threadLocalMap是InternalThreadLocalMap对象实例。
在第一次获取FTL数据时，会初始化FastThreadLocalThread.threadLocalMap，调用的构造函数如下：

//InternalThreadLocalMap
private InternalThreadLocalMap() {
    //为了简便，InternalThreadLocalMap父类
    //UnpaddedInternalThreadLocalMap不展开介绍
    super(newIndexedVariableTable());
}
//默认的数组大小为32，且使用UNSET对象填充数组
//如果下标处数据为UNSET，则表示没有数据
private static Object[] newIndexedVariableTable() {
    Object[] array = new Object[32];
    Arrays.fill(array, UNSET);
    return array;
}

看InternalThreadLocalMap源码可以发现，为了避免伪共享（false sharing）问题，其使用了缓存行填充技术，在类定义中声明了如下long字段进行填充，具体可以参考Disruptor相关文献，基本上所有介绍Disruptor的文章都会提到伪共享问题，在Java8中则可以使用@sun.misc.Contended注解避免伪共享问题。

//InternalThreadLocalMap
// Cache line padding (must be public)
// With CompressedOops enabled, an instance of this class should occupy at least 128 bytes.
public long rp1, rp2, rp3, rp4, rp5, rp6, rp7, rp8, rp9;

上面我们说到FTL保存了数组下标，FTL使用的数组下标是由InternalThreadLocalMap中的静态变量nextIndex统一递增生成的：

//InternalThreadLocalMap

static final AtomicInteger nextIndex = new AtomicInteger();


public static int nextVariableIndex() {
    //Netty中所有FTL数组下标都是通过递增这个静态变量实现的
    //采用静态变量生成所有FTL元素在数组中的下标会造成一个问题，
    //会造成InternalThreadLocalMap中数组不必要的自动扩容
    //这个问题我在文章最后会列出来供讨论。
    int index = nextIndex.getAndIncrement();
    if (index < 0) {
        nextIndex.decrementAndGet();
        throw new IllegalStateException("too many thread-local indexed variables");
    }
    return index;
}

InternalThreadLocalMap中数组大小默认为32，在FTL构造函数中会调用上面的InternalThreadLocalMap.nextVariableIndex()方法获取FTL在该FastThreadLocalThread.threadLocalMap数组下标，因为InternalThreadLocalMap.nextVariableIndex()使用静态域nextIndex递增维护所有FTL的下标，会造成后面实例化的FTL下标过大，如果FTL下标大于其对应FastThreadLocalThread.threadLocalMap数组的Length，会进行数组的自动扩容，如下：

//InternalThreadLocalMap
private void expandIndexedVariableTableAndSet(int index, Object value) {
    Object[] oldArray = indexedVariables;
    final int oldCapacity = oldArray.length;
    //下面复杂的实现是为了将newCapacity规范为最接近的一个2的指数
    int newCapacity = index;
    newCapacity |= newCapacity >>>  1;
    newCapacity |= newCapacity >>>  2;
    newCapacity |= newCapacity >>>  4;
    newCapacity |= newCapacity >>>  8;
    newCapacity |= newCapacity >>> 16;
    newCapacity ++;

    Object[] newArray = Arrays.copyOf(oldArray, newCapacity);
    Arrays.fill(newArray, oldCapacity, newArray.length, UNSET);
    newArray[index] = value;
    indexedVariables = newArray;
}

2.2 FTL类结构

和TL一样，为了使用FTL，我们需要实现其子类，重写初始化函数，在第一次获取时会使用初始化函数initialValue对FTL实际持有的数据进行初始化：

/**
* Returns the initial value for this thread-local variable.
*/
protected V initialValue() throws Exception {
    return null;
}

//FTL还提供了onRemoval钩子函数，
//让使用者在该FTL被移除时可以有机会做些操作。
/**
* Invoked when this thread local variable is removed by {@link #remove()}.
*/
protected void onRemoval(@SuppressWarnings("UnusedParameters") V value) throws Exception { }

上面的继承、初始化原理和TL差不多，不再介绍，如想看实例，则可以看PooledByteBufAllocator.PoolThreadLocalCache的源码。

下面再介绍FTL的三个非常重要的下标域，和TL不同的是，FTL不仅在FastThreadLocalThread.threadLocalMap中保存了用户实际使用的对象（在数组中的下标为index），还在数组中保存为了实现清理记录的相关数据，也即下标variablesToRemoveIndex和cleanerFlagIndex，所以一个FTL的一个实例最多会消耗三个下标，也就最多会占用三个数组位置。

//FastThreadLocal
//如果在该FTL中放入了数据，也就实际调用了其set或get函数，会在
//该FastThreadLocalThread.threadLocalMap数组的
//variablesToRemoveIndex下标处放置一个IdentityHashMap，
//并将该FTL放入IdentityHashMap中，在后续清理时会取出
//variablesToRemoveIndex下标处的IdentityHashMap进行清理
private static final int variablesToRemoveIndex = InternalThreadLocalMap.nextVariableIndex();

//在threadLocalMap数组中存放实际数据的下标
private final int index;

//存放是否已经加入到后台清理线程队列的标志
private final int cleanerFlagIndex;

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

下面看FTL的get方法实现：

//FastThreadLocal
/**
* Returns the current value for the current thread
*/
@SuppressWarnings("unchecked")
public final V get() {
    //初始化或获取该线程的threadLocalMap，下面会分析其源码实现
    InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
    //获取数组在该FTL index下标处的元素
    Object v = threadLocalMap.indexedVariable(index);
    //如果不是默认填充的UNSET，则表示是有效数据，直接返回
    if (v != InternalThreadLocalMap.UNSET) {
        return (V) v;
    }

    //如果没有有效数据，则进行初始化initialize会调用子类
    //实现的initialValue获取初始化数据，如下面列出源码所示
    V value = initialize(threadLocalMap);
    //如果需要的话，将该FTL注册到后台清理任务中，
    //后文在介绍清理时会介绍
    registerCleaner(threadLocalMap);
    return value;
}

 private V initialize(InternalThreadLocalMap threadLocalMap) {
    V v = null;
    try {
        v = initialValue();
    } catch (Exception e) {
        PlatformDependent.throwException(e);
    }
    //设置该下标处的值为初始值，如果下标大于数组容量，则会进行扩容
    threadLocalMap.setIndexedVariable(index, v);
    //将FTL放到该map数组下标variablesToRemoveIndex对应的
    //IdentityHashMap中为后续清理做准备。
    addToVariablesToRemove(threadLocalMap, this);
    return v;
}

下面看InternalThreadLocalMap.get()实现：

//InternalThreadLocalMap
public static InternalThreadLocalMap get() {
    Thread thread = Thread.currentThread();
    //首先看当前thread是否为FastThreadLocalThread实例
    //如果是的话，上文介绍过，可以快速获取到其threadLocalMap
    if (thread instanceof FastThreadLocalThread) {
        return fastGet((FastThreadLocalThread) thread);
    } else {
        //如果不是，则慢速获取到其threadLocalMap
        return slowGet();
    }
}

//如果当前thread是FastThreadLocalThread实例，则直接获取其
//threadLocalMap域，第一次获取则进行初始化
private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
    InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
    if (threadLocalMap == null) {
        thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
    }
    return threadLocalMap;
}

//如果当前thread不是FastThreadLocalThread实例，则在Java
//原生ThreadLocal中放置一个InternalThreadLocalMap，然后再
//返回，InternalThreadLocalMap放在原生TL中，获取速度比较慢
private static InternalThreadLocalMap slowGet() {
    //见下面代码，这样访问会在Java原生ThreadLocal
    //中放置一个InternalThreadLocalMap
    ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = UnpaddedInternalThreadLocalMap.slowThreadLocalMap;
    InternalThreadLocalMap ret = slowThreadLocalMap.get();
    if (ret == null) {
        ret = new InternalThreadLocalMap();
        slowThreadLocalMap.set(ret);
    }
    return ret;
}

//UnpaddedInternalThreadLocalMap
static final ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = new ThreadLocal<InternalThreadLocalMap>();

3 FTL数据设置或获取

3.1 数据放置

数据放置比较简单，主要涉及到FTL的get和set方法，get方法上面已经列出过源码，下面主要看set方法：

//FastThreadLocal
/**
* Set the value for the current thread.
*/
public final void set(V value) {
    //如果设置的值不为默认填充的UNSET才进行设置
    if (value != InternalThreadLocalMap.UNSET) {
        //获取该线程对应的map对象
        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
        //在map对象中放置该值
        if (setKnownNotUnset(threadLocalMap, value)) {
            //如果需要的话，将该map注册到后台清理任务中，
            //后文在介绍清理时会介绍
            registerCleaner(threadLocalMap);
        }
    } else {
        //如果放置的对象为UNSET，则表示清理，会对该FTL进行清理
        remove();
    }
}


/**
* @return see {@link InternalThreadLocalMap#setIndexedVariable(int, Object)}.
*/
private boolean setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value) {
    //在数组下标index处放置实际对象，如果index大于数组length，
    //会进行数组扩容，可见上面的源码。
    //放置成功之后，将该FTL加入到variablesToRemoveIndex下标的
    //IdentityHashMap，等待后续清理
    if (threadLocalMap.setIndexedVariable(index, value)) {
        addToVariablesToRemove(threadLocalMap, this);
        return true;
    }
    return false;
}

//该FTL加入到variablesToRemoveIndex下标的IdentityHashMap
//IdentityHashMap的特性可以保证同一个实例不会被多次加入到该位置
@SuppressWarnings("unchecked")
private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
    //获取variablesToRemoveIndex下标处的IdentityHashMap
    Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
    Set<FastThreadLocal<?>> variablesToRemove;
    //如果是第一次获取，则variablesToRemoveIndex下标处的值
    //为UNSET，所以下面会新建一个新的IdentityHashMap并
    //放入到下标variablesToRemoveIndex处
    if (v == InternalThreadLocalMap.UNSET || v == null) {
        variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());
        threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove);
    } else {
        //如果不是第一次访问variablesToRemoveIndex下标，则该
        //下标对应的元素已经是IdentityHashMap，所以直接类型转换
        variablesToRemove = (Set<FastThreadLocal<?>>) v;
    }
    //将该FTL放入该IdentityHashMap中
    variablesToRemove.add(variable);
}

3.2 数据获取

FTL数据获取见get方法，上面已经列出其源码，这里不再赘述。

4 清理

4.1 主动清理

上面在介绍FastThreadLocalThread类时，提到其有一个字段为cleanupFastThreadLocals，这个字段则用于标识该线程在结束时是否会主动清理FTL。下面看FastThreadLocalThread构造函数，被FastThreadLocalRunnable.wrap方法修饰的Runnable会将cleanupFastThreadLocals置为true，表示FTL会在线程结束时被主动清理，wrap方法会把原Runnable.run方法放在try里，然后在finally中调用FastThreadLocal.removeAll()方法，该方法会对FTL进行清理，具体可看下面列出的源码。没有被wrap的则cleanupFastThreadLocals为false，需要将FTL放入后台清理线程的队列中，其实就对应上面出现多次的registerCleaner方法：

//FastThreadLocalThread
public FastThreadLocalThread() {
    cleanupFastThreadLocals = false;
}

public FastThreadLocalThread(Runnable target) {
    super(FastThreadLocalRunnable.wrap(target));
    cleanupFastThreadLocals = true;
}

public FastThreadLocalThread(ThreadGroup group, Runnable target) {
    super(group, FastThreadLocalRunnable.wrap(target));
    cleanupFastThreadLocals = true;
}

public FastThreadLocalThread(String name) {
    super(name);
    cleanupFastThreadLocals = false;
}

public FastThreadLocalThread(ThreadGroup group, String name) {
    super(group, name);
    cleanupFastThreadLocals = false;
}

public FastThreadLocalThread(Runnable target, String name) {
    super(FastThreadLocalRunnable.wrap(target), name);
    cleanupFastThreadLocals = true;
}

public FastThreadLocalThread(ThreadGroup group, Runnable target, String name) {
    super(group, FastThreadLocalRunnable.wrap(target), name);
    cleanupFastThreadLocals = true;
}

public FastThreadLocalThread(ThreadGroup group, Runnable target, String name, long stackSize) {
    super(group, FastThreadLocalRunnable.wrap(target), name, stackSize);
    cleanupFastThreadLocals = true;
}

//FastThreadLocalRunnable
final class FastThreadLocalRunnable implements Runnable {
    private final Runnable runnable;

    private FastThreadLocalRunnable(Runnable runnable) {
        this.runnable = ObjectUtil.checkNotNull(runnable, "runnable");
    }

    @Override
    public void run() {
        try {
            runnable.run();
        } finally {
            FastThreadLocal.removeAll();
        }
    }

    static Runnable wrap(Runnable runnable) {
        //被wrap的Runable会变成FastThreadLocalRunnable对象
        //FastThreadLocalRunnable在run方法的finally会调用
        //FastThreadLocal.removeAll();在线程结束时对FTL
        //进行主动清理
        return runnable instanceof FastThreadLocalRunnable ? runnable : new FastThreadLocalRunnable(runnable);
    }
}

主动清理调用的FastThreadLocal.removeAll()源码如下：

//FastThreadLocal
/**
* 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() {
    //首先看能够获取该线程对应的threadLocalMap，如果从来没有
    //访问过该线程的FTL，则获取的为null，不用执行任何清理，直接
    //return
    InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.getIfSet();
    if (threadLocalMap == null) {
        return;
    }

    try {
        //否则获取下标variablesToRemoveIndex上对应的IdentityHashMap
        Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
        //成功获取到IdentityHashMap
        if (v != null && v != InternalThreadLocalMap.UNSET) {
            @SuppressWarnings("unchecked")
            Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
            //转成数组
            FastThreadLocal<?>[] variablesToRemoveArray =
                    variablesToRemove.toArray(new FastThreadLocal[variablesToRemove.size()]);
            //对IdentityHashMap中的每个FTL，进行清理
            for (FastThreadLocal<?> tlv: variablesToRemoveArray) {
                tlv.remove(threadLocalMap);
            }
        }
    } finally {
        //因为这里是线程结束的主动清理，线程结束则threadLocalMap
        //也不再会被使用，所以这里清理线程的threadLocalMap
        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;
    }
    //移除下标index处的实际数据（应用程序初始化的数据）
    Object v = threadLocalMap.removeIndexedVariable(index);
    //获取下标variablesToRemoveIndex处的IdentityHashMap，并将该
    //IdentityHashMap中记录的正在移除的FTL删除
    removeFromVariablesToRemove(threadLocalMap, this);

    if (v != InternalThreadLocalMap.UNSET) {
        try {
            //这里调用上面2.2节提到的可供用户自定义的onRemoval钩子函
            //数
            onRemoval((V) v);
        } catch (Exception e) {
            PlatformDependent.throwException(e);
        }
    }
}

线程主动清理的实现比较简单，首先找到线程的threadLocalMap，因为每次在访问FTL时，FTL都会将自己放置到数组下标variablesToRemoveIndex处的IdentityHashMap中，清理时也就找到在下标variablesToRemoveIndex处的IdentityHashMap，移除所有的FTL，最后线程退出，将线程的threadLocalMap置空。

4.2 后台线程清理

没能被FastThreadLocalRunnable.wrap方法修饰的Runnable任务，无法通过finally语句块做到主动清理，因此FastThreadLocalThread.cleanupFastThreadLocals = false，上面在介绍FastThreadLocal的set和get方法时，发现都调用了registerCleaner方法，这个方法就是将清理任务注册到专门负责清理工作的后台线程中，下面看其源码：

//FastThreadLocal
private void registerCleaner(final InternalThreadLocalMap threadLocalMap) {
    Thread current = Thread.currentThread();
    //willCleanupFastThreadLocals就是排除上面主动清理的情形，如果
    //线程能自己主动清理，那么不需要将清理任务注册到后台清理线程中
    if (FastThreadLocalThread.willCleanupFastThreadLocals(current) ||
        //数组下标cleanerFlagIndex在上面介绍过，主要为了标记
        //该FTL有没有被注册到后台清理线程中，第一次注册之后，
        //会将该下标对应的数组位置置为true，如果已经注册过，
        //则不用重复注册
        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.
    //如果不是主动清理，且第一次注册，则将该下标对应的
    //数组元素置为true，表示已经注册过
    threadLocalMap.setIndexedVariable(cleanerFlagIndex, Boolean.TRUE);

    // We will need to ensure we will trigger remove(InternalThreadLocalMap) so everything will be released
    // and FastThreadLocal.onRemoval(...) will be called.
    //向后台线程注册一个清理任务
    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.
        }
    });
}

这里run函数里实际清理方法remove(threadLocalMap)的实现的实现在上面介绍主动清理时已经介绍，下面主要看ObjectCleaner.register实现：

//ObjectCleaner
/**
* Register the given {@link Object} for which the {@link Runnable} will be executed once there are no references
* to the object anymore.
*
* This should only be used if there are no other ways to execute some cleanup once the Object is not reachable
* anymore because it is not a cheap way to handle the cleanup.
*/
public static void register(Object object, Runnable cleanupTask) {
    //根据当前线程和上面的清理任务构造一个reference
    //AutomaticCleanerReference是WeakReference子类
    AutomaticCleanerReference reference = new AutomaticCleanerReference(object,
            ObjectUtil.checkNotNull(cleanupTask, "cleanupTask"));
    // Its important to add the reference to the LIVE_SET before we access CLEANER_RUNNING to ensure correct
    // behavior in multi-threaded environments.
    //将该reference放入LIVE_SET中，等待清理线程清理
    LIVE_SET.add(reference);

    //如果清理线程已经退出，则新建一个清理线程
    // Check if there is already a cleaner running.
    if (CLEANER_RUNNING.compareAndSet(false, true)) {
        //该线程实际工作由Runnable CLEANER_TASK定义
        final Thread cleanupThread = new FastThreadLocalThread(CLEANER_TASK);
        cleanupThread.setPriority(Thread.MIN_PRIORITY);
        // Set to null to ensure we not create classloader leaks by holding a strong reference to the inherited
        // classloader.
        // See:
        // - https://github.com/netty/netty/issues/7290
        // - https://bugs.openjdk.java.net/browse/JDK-7008595
        //避免classLoader造成内存泄漏，所以设置线程上下文
        //加载器为null
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            @Override
            public Void run() {
                cleanupThread.setContextClassLoader(null);
                return null;
            }
        });
        cleanupThread.setName(CLEANER_THREAD_NAME);

        //设置为daemon线程，避免不退出
        // Mark this as a daemon thread to ensure that we the JVM can exit if this is the only thread that is
        // running.
        cleanupThread.setDaemon(true);
        cleanupThread.start();
    }
}

后台清理线程的实际工作定义在CLEANER_TASK中，所以下面看其源码实现：

//ObjectCleaner
private static final Runnable CLEANER_TASK = new Runnable() {
    @Override
    public void run() {
        boolean interrupted = false;
        for (;;) {
            // 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.
            //如果LIVE_SET不为空，则表示还有清理任务没有完成
            //使用while循环进行清理
            while (!LIVE_SET.isEmpty()) {
                //AutomaticCleanerReference是WeakReference子类
                //所以如果没有强引用，那么在GC时会被回收
                //并将引用自身放入队列中
                final AutomaticCleanerReference reference;
                try {
                    //这里就从队列中取出被回收的reference
                    //remove可能会被中断，在catch中会记录
                    //中断标志
                    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 {
                        //这里的cleanup方法实际上调用的是
                        //FastThreadLocal注册的Runnable，主要
                        //调用remove(threadLocalMap)方法
                        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中移除该引用
                    LIVE_SET.remove(reference);
                }
            }//while
            //设置该清理线程运行状态为非运行
            CLEANER_RUNNING.set(false);

            // Its important to first access the LIVE_SET and then CLEANER_RUNNING to ensure correct
            // behavior in multi-threaded environments.
            //发生下面两种情况线程可以结束：
            //（1）如果LIVE_SET为空，已经没有清理任务
            //（2）上面已经将CLEANER_RUNNING置为false，如果
            //下面compareAndSet(false, true)失败，
            //则表示已经有其他线程注册清理
            //任务时重新启动了一个新的线程，所以为了保证只有一个
            //线程在运行，这里也退出线程
            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;
            }
        }//for
        //如果线程被中断过，则恢复中断标志
        if (interrupted) {
            // As we caught the InterruptedException above we should mark the Thread as interrupted.
            Thread.currentThread().interrupt();
        }
    }
};

5 阅读源码发现的一个问题

上面说到FTL会维护三个下标，一个保存实际的数据，其他两个和数据清理有关，且三个下标都由InternalThreadLocalMap的静态域nextIndex递增产生，每个threadLocalMap数组默认大小为32，这样就会有一个问题，如果有12个线程，每个线程声明了1个FTL，且每个FTL都实际消耗了三个下标，那么前面11个线程的FTL会将nextIndex递增为32，第12个线程的FTL数据下标为34（这里是34，因为FTL的variablesToRemoveIndex先于数据下标index被初始化为33）,该线程的threadLocalMap容量为32，但是因为该FTL下标为34，所以在设置数据时，如下面代码所示，会触发一次扩容，虽然数组容量32一个位置都还没有被实际使用：

//InternalThreadLocalMap
public boolean setIndexedVariable(int index, Object value) {
    Object[] lookup = indexedVariables;
    //index为34， lookup.length为32，所以进入else进行扩容
    if (index < lookup.length) {
        Object oldValue = lookup[index];
        lookup[index] = value;
        return oldValue == UNSET;
    } else {
        expandIndexedVariableTableAndSet(index, value);
        return true;
    }
}