Netty进阶：自顶向下解析FastThreadLocal

FastThreadLocalThread 分析

我们知道EventLoopGroup相当于线程池，而EventLoop是其中的线程，用来执行IO任务和一些handler中的业务逻辑。在Netty进阶：Netty核心NioEventLoop原理解析文章中详解的介绍了EventLoopGroup和EventLoop的构造过程，以及他们如何去执行IO任务等。但是关于NioEventLoop中持有的Executor引用并没有做过多的解释。Executor是JDK提供的一个线程池接口，只有一个execte方法。下面对Netty对Executor的实现做一个详细的阐述。

NioEventLoopGroup的父类MultithreadEventExecutorGroup的构造函数中对Executor的赋值语句如下：

executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());

ThreadPerTaskExecutor是Netty对JDK Exectuor的实现类。这个类的实现非常简单

public final class ThreadPerTaskExecutor implements Executor {
    // 每一个EventLoopGroup对应一个ThreadPerTaskExecutor
    private final ThreadFactory threadFactory;
    // 构造函数
    public ThreadPerTaskExecutor(ThreadFactory threadFactory) {
        if (threadFactory == null) {
            throw new NullPointerException("threadFactory");
        }
        this.threadFactory = threadFactory;
    }
    // 实现Executor的方法
    @Override
    public void execute(Runnable command) {
        threadFactory.newThread(command).start();
    }
}

这里有一个疑惑，Netty为什么不用JDK提供的Exector接口的多个实现(Executors有对ThreadFactory的实现)？

可以看到threadFactory.newThread(command).start();的意思是创建一个新的线程并且启动。我们继续跟进ThreadFactory的实现；

@Override
public Thread newThread(Runnable r) {
    Thread t = newThread(FastThreadLocalRunnable.wrap(r), prefix + nextId.incrementAndGet());
    // 一般daemon为false，意思是不设置为守护线程
    if (t.isDaemon() != daemon) {
        t.setDaemon(daemon);
    }
    // 优先级 默认为5
    if (t.getPriority() != priority) {
        t.setPriority(priority);
    }
    return t;
}

protected Thread newThread(Runnable r, String name) {
    return new FastThreadLocalThread(threadGroup, r, name);
}

可以看到创建了一个FastThreadLocalThread类型的线程。FastThreadLocalThread继承自Thread类，看它的两个属性

// 任务执行完，是否清除FastThreadLocal的标记
private final boolean cleanupFastThreadLocals;
// 类似于Thread类中ThreadLocalMap，为了实现FastThreadLocal
private InternalThreadLocalMap threadLocalMap;

说了这么多终于讲到本文的主题，前面所说的这个过程是为了让大家明白EventLoop中的线程都是FastThreadLocalThread类型的。并且在此类型的线程中有一个属性叫做InternalThreadLocalMap，该属性是为了实现FastThreadLocal。

优雅的使用 FastThreadLocal

下面演示两种方式，分别是Netty提供的ThreadFactory和手动创建FastThreadLoalThread。

FastThreadLocal<String> threadLocal = new FastThreadLocal() {
    @Override
    protected String initialValue() throws Exception {
        return "hello netty";
    }

    @Override
    protected void onRemoval(Object value) throws Exception {
        System.out.println("value has be removed");
    }
};

new DefaultThreadFactory("FastThread-Pool")
    .newThread(() -> {
        System.out.println(threadLocal.get());
    }
).start();

new FastThreadLocalThread(() -> {
        threadLocal.set("hello FastThreadLocalThread");
        System.out.println(threadLocal.get());
    }
).start();

/** 输出
hello netty
value has be removed
hello FastThreadLocalThread
value has be removed
*/

首先重写FastThreadLocal的initValue方法很容易理解，和ThreadLocal中的一样，那么重写的onRemoval方法看样子应该是FastThreadLocal移除是会被调用。
在JDK的ThreadLocal中一般我们通过ThreadLocal.remove方法移除value。在这里似乎当线程把任务执行完毕后会自动的调用类似于remove的方法。
这个逻辑是在创建线程的过程添加进去的，Netty把Runnable的匿名类封装成一个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方法中会调用我们实现的onRemoval方法
            FastThreadLocal.removeAll();
        }
    }

    static Runnable wrap(Runnable runnable) {
        return runnable instanceof FastThreadLocalRunnable ? runnable : new FastThreadLocalRunnable(runnable);
    }
}

看到这里就明白了为什么重写的onRemoval方法会被执行了,线程池中的线程由于会被复用，所以线程池中的每一条线程在执行task结束后，要清理掉其InternalThreadLocalMap和其内的FastThreadLocal信息，否则InternalThreadLocalMap信息还存储着上一次被使用时的信息；另外，假设这条线程不再被使用，但是这个线程有可能不会被销毁（与线程池的类型和配置相关），那么线程上的FastThreadLocal将发生资源泄露。

1. InternalThreadLocalMap 底层数据结构

InternalThreadLocalMap的父类是UnpaddedInternalThreadLocalMap，该类中指定了保存数据的结构。

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

// FastMap
static final AtomicInteger nextIndex = new AtomicInteger();
Object[] indexedVariables;

有些情况下，我们自己创建的线程并没有使用FastThreadLocalThread,为了适配这种情况，Netty通过Thread原生的ThreadLocal来保存InternalThreadLocalMap。关系图如下：

即Thread中的属性threadLocalMap中key是上面定义的：ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap,注意这是一个静态变量。

如果使用了FastThreadLocalThread,那么存储数据的结构直接使用Netty定义的InternalThreadLocalMap，通过Object[] indexedVariables保存key(FastThreadLocal)和value。nextIndex是一个自增的数组下表。JDK的ThreadLocal是通过Hash计算到下表，遇到冲突通过线性探测法解决。Netty确定了每一个key对应的value在数组中的下标，因此不会有冲突发生。

下面看一下它的构造方法

private InternalThreadLocalMap() {
  super(newIndexedVariableTable());
}
private static Object[] newIndexedVariableTable() {
	// 创建数据，填充Object对象
    Object[] array = new Object[32];
    Arrays.fill(array, UNSET);
    return array;
}

2. FastThreadLocal

在前面也介绍到FastThreadLocal的用法，和JDK提供的ThreadLcal几乎没出入。下面就一起探索它的内部实现细节。

// 常量0，存放FastThreadLocal集合的下标
private static final int variablesToRemoveIndex = InternalThreadLocalMap.nextVariableIndex();
// 每一个FastThreadLocal对应的Value的下标
private final int index;
private final int cleanerFlagIndex;

构造方法为：

public FastThreadLocal() {
    // 每一个FastThreadLocal对象的index都是不同的，因此确定了 value在数组中的位置
    index = InternalThreadLocalMap.nextVariableIndex();
    // 清除标记位
    cleanerFlagIndex = InternalThreadLocalMap.nextVariableIndex();
}

构造完成之后，进入set和get方法

3. set

set方法的目的是以当前FastThreadLocal为key，设置value到当前FastThreadLocalThread类型线程的 InternalThreadLocalMap实例中。

public final void set(V value) {
    // UNSET为空的Object对象，不允许为空
    if (value != InternalThreadLocalMap.UNSET) {
        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
        setKnownNotUnset(threadLocalMap, value);
    } else {
        remove();
    }
}

前面说到有两种情况，即线程类型是否为FastThreadLocalThread

1. 根据不同的线程类型获取不同的InternalThreadLocalMap
2. 设置value

3.1 获取map

InternalThreadLocalMap.get实现如下：

public static InternalThreadLocalMap get() {
    Thread thread = Thread.currentThread();
    if (thread instanceof FastThreadLocalThread) {
        return fastGet((FastThreadLocalThread) thread);
    } else {
        return slowGet();
    }
}

判断当前线程的类型，如果是FastThreadLocalThread类型，则使用该类内部属性InternalThreadLocalMap，否则使用原生Thread对象中的ThreadLocalMap属性来，然后在此
map中保存key为JDK中的ThreadLocal对象，value为InternalThreadLocalMap（Netty中的类）。

fastGet的逻辑是获取InternalThreadLocalMap，如果不存在那么新创建一个。

private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
    InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
    if (threadLocalMap == null) {
        // 设置到FastThreadLocalThread对象内部的属性中
        thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
    }
    return threadLocalMap;
}

slowGet获取当前线程ThreadLocaMap中key为slowThreadLocalMap（定义声明在UnpaddedInternalThreadLocalMap的常量），value是InternalThreadLocalMap。

private static InternalThreadLocalMap slowGet() {
    ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = UnpaddedInternalThreadLocalMap.slowThreadLocalMap;
    InternalThreadLocalMap ret = slowThreadLocalMap.get();
    if (ret == null) {
        ret = new InternalThreadLocalMap();
        slowThreadLocalMap.set(ret);
    }
    return ret;
}

3.2 设置value

当 InternalThreadLocalMap.get() 返回了 一个 InternalThreadLocalMap，接下来就可以保存数据了。

private boolean setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value) {
    // 设置value
    if (threadLocalMap.setIndexedVariable(index, value)) {
        //将key（FastThreadLoca）添加到数组的第一个元素（Set集合）中
        addToVariablesToRemove(threadLocalMap, this);
        return true;
    }
    return false;
}

下面还是逐一分析，分析一下设置value的内部逻辑：

public boolean setIndexedVariable(int index, Object value) {
    // indexedVariables是构造函数中创建的Object数组
    Object[] lookup = indexedVariables;
    // index是从FastThreadLcal中传入的值，初始为1（自增），因为0被静态变量variablesToRemoveIndex抢占了
    if (index < lookup.length) {
        Object oldValue = lookup[index];
        lookup[index] = value;
        return oldValue == UNSET;
    } else {
        expandIndexedVariableTableAndSet(index, value);
        return true;
    }
}

整体逻辑比较直观，如果index没有越界，那么进行覆盖，如果old value为 UNSET，那么返回true，否则返回false。如果越界则进行扩容并返回true。这里有一个小细节。只有一种情况会返回fasle，即某个元素已经被赋值过了。那么返回false直接影响的是addToVariablesToRemove方法不会执行。即key不会再次被添加到Set集合中。因为已经被添加过了。下面看一下经典的扩容方式：

private void expandIndexedVariableTableAndSet(int index, Object value) {
    Object[] oldArray = indexedVariables;
    final int oldCapacity = oldArray.length;
    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的幂次方。JDK中HashMap的扩容也类似。扩容完成之后填充UNSET，并且将保存value。至此保存value的操作已经完毕。下面分析保存key的过程：

private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
    // 获取到下表为0的数组元素
    Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
    Set<FastThreadLocal<?>> variablesToRemove;
    // 如果未设置过或者为null
    if (v == InternalThreadLocalMap.UNSET || v == null) {
        // 创建一个IdentityHashMap的实现,IdentityHashMap和HashMap类似，只是key的相同判断方式以 ‘==’来决定
        variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());
         // 将这个 Set 放到这个 Map 数组的下标 0 处
        threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove);
    } else {
        // 如果拿到的不是 UNSET ，说明这是第二次操作了，因此可以强转为 Set
        variablesToRemove = (Set<FastThreadLocal<?>>) v;
    }
    // 将 FastThreadLocal 放置到 Set 中
    variablesToRemove.add(variable);
}

这个方法的目的是将一条线程的所有FastThreadLocal对象保存到一个 Set 中，静态方法 removeAll 就需要使用到这个 Set，可以快速的删除线程 Map 里的所有 FTL 对应的 Value。如果不使用 Set，那么就需要遍历 InternalThreadLocalMap。

4. get

get方法极为简单，实现如下：

public final V get() {
    InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
    Object v = threadLocalMap.indexedVariable(index);
    if (v != InternalThreadLocalMap.UNSET) {
        return (V) v;
    }

    V value = initialize(threadLocalMap);
    registerCleaner(threadLocalMap);
    return value;
}

首先获取当前线程的map，然后根据 FastThreadLocal的index 获取value，然后返回，如果是空对象，则通过 initialize 返回，initialize 方法会将返回值设置到 map 的槽位中，并放进 Set 中。最后，尝试注册一个清洁器。
我们跟进初始化操作

private V initialize(InternalThreadLocalMap threadLocalMap) {
    V v = null;
    try {
        //1、获取初始值
        v = initialValue();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    // 2、设置value到InternalThreadLocalMap中
    threadLocalMap.setIndexedVariables(index, v);
    // 3、添加当前的FastThreadLocal到InternalThreadLocalMap的Set<FastThreadLocal<?>>中
    addToVariablesToRemove(threadLocalMap, this);

    return v;
}

//初始化参数：由子类复写
protected V initialValue() throws Exception {
    return null;
}

initialize过程和set过程几乎一样，此处不再赘述。

5. remove

FastThreadLocal有两种删除操作，删除当前线程上的InternalThreadLocalMap中的每一个value以及threadLocalMap本身。单个删除当前的FastThreadLocal对象的值。

public static void removeAll() {
    // 获取到map
    InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.getIfSet();
    if (threadLocalMap == null) {
        return;
    }

    try {
        // 获取到Set<FastThreadLocal>集合
        Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
        if (v != null && v != InternalThreadLocalMap.UNSET) {
            @SuppressWarnings("unchecked")
            Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
            // 将Set转换为数组
            FastThreadLocal<?>[] variablesToRemoveArray =
                    variablesToRemove.toArray(new FastThreadLocal[variablesToRemove.size()]);
            // 遍历数组，删除每一个FastThreadLocal对应的value
            for (FastThreadLocal<?> tlv: variablesToRemoveArray) {
                tlv.remove(threadLocalMap);
            }
        }
    } finally {
        // 删除当前线程的InternalThreadLocalMap
        InternalThreadLocalMap.remove();
    }
}

tlv.remove单个删除过程如下：

private void remove() {
    remove(InternalThreadLocalMap.getIfSet());
}

private void remove(InternalThreadLocalMap threadLocalMap) {
    if (threadLocalMap == null) {
        return;
    }
    // 从 InternalThreadLocalMap 中删除当前的FastThreadLocal对应的value
    Object v = threadLocalMap.removeIndexedVariable(index);
    // 从 InternalThreadLocalMap 中的Set<FastThreadLocal<?>>中删除当前的FastThreadLocal对象
    removeFromVariablesToRemove(threadLocalMap, this);
    // 如果删除的是有效值，则进行onRemove方法的回调
    if (v != InternalThreadLocalMap.UNSET) {
        try {
            // 回调子类复写的onRemoved方法，默认为空实现
            onRemoved((V) v);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

代码非常直观，继续分析删除map的操作

public static void remove() {
    Thread thread = Thread.currentThread();
    if (thread instanceof FastThreadLocalThread) {
         // 将FastThreadLocalThread 内部的map置位null
        ((FastThreadLocalThread) thread).setThreadLocalMap(null);
    } else {
        // 将 ThreadLocal内部ThreadLocalMap 中的value置位null
        slowThreadLocalMap.remove();
    }
}

removeAll操作会在FastThreadLocal线程自动的执行，但是普通类型的线程只能通过手动的remove/removeAll，但是Netty作者提供了另外一个神器ObjectCleaner。
专门对普通线程中FastThreadLocal的回收操作。

总结 FastThreadLocal使用的数组替代JDK中的线性探测发法的Map，如果是Netty内部创建的线程不用担心内存泄漏的，如果开发者使用了普通的线程，Netty 仍然会借助 JDK 的 ThreadLocal，只是只借用一个槽位，放置 Netty的Map