Netty的FastThreadLocal到底有多快？

石杉的架构笔记

于 2022-06-08 07:50:23 发布

阅读量387

点赞数

文章标签： java 算法 android 面试分布式

原文链接：https://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247539049&idx=1&sn=8d58a3f406e423aeaf3671c4188cbca5&chksm=fba5b16accd2387ca9b604abd738f897aad2805a10f3cee984fabaf1311f7f199ed85cbb589d&scene=126&&sessionid=0

版权

文章来源：https://c1n.cn/T13rl‍‍

前言
解决的问题
对比 JDK 自带的 ThreadLocal
FastThreadLocal 为什么快
FastThreadLocal 源码分析
总结

前言

本文使用 Netty 源码版本为 netty-4.1.36.Final，在了解 FastThreadLocal 之前，可以先了解 ThreadLocal。

解决的问题

在多线程环境下访问共享变量？大家都能想到的是通过加锁串行化处理可以解决，但是在高并发的场景下，加锁操作是不是就存在瓶颈了？

JDK 自带的 ThreadLocal 的出现，可以保证多线程下无锁化的线程安全；可以发现很多开源框架中大量使用了 ThreadLocal 解决这一类问题。

FastThreadLocal 为什么出现？离开了具体场景谈技术的应用难免有些不妥，再好的东西也有它最适用的范围。

基于 Netty 的应用场景，演化出了更适用于它的 FastThreadLocal 来访问控制共享变量。

对比 JDK 自带的 ThreadLocal

对于 ThreadLocal 这种线程间数据隔离方案，真实的数据维护其实是由线程自己维护并引用。

比如 JDK 的 ThreadLocal 实现方案是由线程内部维护了一张 Map 结构存储这些数据，用的时候直接取就可以。

JDK自带的 ThreadLocal，Thread 内部维护了 ThreadLocal.ThreadLocalMap 这样一个引用关系，使用的 hash + 线性探测解决冲突的一套方案。

这套方案在大多场景下性能都是很 OK 的，毕竟一个 Thread 内部也不会存在很多 ThreadLocal 对象，换句话说，存在 hash 冲突的情况就很小，那读写操作都是 O(1) 自然性能很好，又能回收并复用过期的 hash 槽，空间效率也很 OK。

但对于一个线程内部可能出现很多的 ThreadLocal 对象的场景，JDK 那套 hash 冲突的解决方案可能就不那么美妙了。

对于 Netty 这套网络通信框架而言，即有底层通信层的封装、也有编/解码的处理、更很多业务层的逻辑，可能存在一个线程中维护很多 threadLocal 对象的场景，因此 Netty 从 JDK 的 TreadLocal 中衍生出适合自己业务的 FastThreadLocal。

主要的改进场景在于：线程维护的结构由 Map 变成了 Array 数组结构，最大的好处是可以 O(1) 读写，但也存在数据很大的场景；典型的空间换时间思想的应用。

FastThreadLocal 为什么快

| 重要结构

‍‍‍‍‍‍FastThreadLocal 的实现与 ThreadLocal 非常类似，Netty 为 FastThreadLocal 量身打造了 FastThreadLocalThread 和 InternalThreadLocalMap 两个重要的类。

FastThreadLocalThread 是对 Thread 类做了一层扩展，也就是通过扩展的 InternalThreadLocalMap 结构维护自己的一套数据。

只有 FastThreadLocal 和 FastThreadLocalThread 组合使用时，才能发挥 FastThreadLocal 的性能优势。

因为不使用 FastThreadLocalThread 就没有扩展结构存储数据。

public class FastThreadLocalThread extends Thread {

    private InternalThreadLocalMap threadLocalMap;

    // 省略其他代码

}

有了自己扩展的结构 InternalThreadLocalMap，就可以不再使用 Thread 中的 ThreadLocalMap。

所以想知道 FastThreadLocalThread 高性能的奥秘，必须要了解 InternalThreadLocalMap 的设计原理。

| 提升的关键

前面讲到 ThreadLocal 的一个重要缺点，就是 ThreadLocalMap 采用线性探测法解决 Hash 冲突性能较慢，那么 InternalThreadLocalMap 又是如何优化的呢？

先来看看 InternalThreadLocalMap 的内部构造：

public final class InternalThreadLocalMap extends UnpaddedInternalThreadLocalMap {

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(InternalThreadLocalMap.class);

    private static final int DEFAULT_ARRAY_LIST_INITIAL_CAPACITY = 8;
    private static final int STRING_BUILDER_INITIAL_SIZE;
    private static final int STRING_BUILDER_MAX_SIZE;

    public static final Object UNSET = new Object();

    private BitSet cleanerFlags;

    // ...

    public static InternalThreadLocalMap get() {
        Thread thread = Thread.currentThread();
        if (thread instanceof FastThreadLocalThread) {
            return fastGet((FastThreadLocalThread) thread);
        } else {
            // 兜底操作, 如果不是FastThreadLocalThread，就使用JDK的ThreadLocal处理
            return slowGet();
        }
    }

    public static void remove() {
        Thread thread = Thread.currentThread();
        if (thread instanceof FastThreadLocalThread) {
            ((FastThreadLocalThread) thread).setThreadLocalMap(null);
        } else {
            slowThreadLocalMap.remove();
        }
    }

    // 通过线程内部的AtomicInteger原子性递增的获取数据下标
    // 随着逐步递增，下标也越来越大，也就是数组越来越大，这是它最大的缺点之一
    public static int nextVariableIndex() {
        int index = nextIndex.getAndIncrement();
        if (index < 0) {
            nextIndex.decrementAndGet();
            throw new IllegalStateException("too many thread-local indexed variables");
        }
        return index;
    }

    // ...

在 FastThreadLocal 初始化的时候分配一个数组索引 index，index 的值采用原子类 AtomicInteger 保证顺序递增，通过调用 InternalThreadLocalMap.nextVariableIndex() 方法获得。

然后在读写数据的时候通过数组下标 index 直接定位到 FastThreadLocal 的位置，时间复杂度为 O(1)。

如果数组下标递增到非常大，那么数组也会比较大，所以 FastThreadLocal 是通过空间换时间的思想提升读写性能。

InternalThreadLocalMa p数组下标 0 存的非实质性数据，是一个 Set<FastThreadLocal<?>> 类型，也就是所有的 FastThreadLocal 引用集合，用于扩展 remove 操作。

从数组下标 1 开始都是直接存储的 value 数据，不再采用 ThreadLocal 的键值对形式进行存储。

InternalThreadLocalMap、index 和 FastThreadLocal 之间的关系如下图：

FastThreadLocal 源码分析

| 使用差异

从基本的使用上来看和 ThreadLocal 基本没有差异，只需要把代码中 Thread、ThreadLocal 替换为 FastThreadLocalThread 和 FastThreadLocal 即可。

下面我们重点对示例中用得到 FastThreadLocal.set()/get() 方法做深入分析。

| 重点实现

FastThreadLocal.set()：

/**
     * 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();
        }
    }

判断 value 是否为缺省值，如果等于缺省值，那么直接调用 remove() 方法。如果 value 不等于缺省值，接下来会获取当前线程的 InternalThreadLocalMap。然后将 InternalThreadLocalMap 中对应数据替换为新的 value。

InternalThreadLocalMap.get()：

public static InternalThreadLocalMap get() {
        Thread thread = Thread.currentThread();
        // 如果是FastThreadLocalThread类型，则从FastThreadLocalThread中拿去
        if (thread instanceof FastThreadLocalThread) {
            return fastGet((FastThreadLocalThread) thread);
        } else {
            // 兜底操作
            // 从JDK的ThreadLocal中获取
            return slowGet();
        }
    }

    private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
        InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
        // 如果此时 InternalThreadLocalMap 不存在，直接创建一个返回
        if (threadLocalMap == null) {
            thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
        }
        return threadLocalMap;
    }

    private static InternalThreadLocalMap slowGet() {
        ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = UnpaddedInternalThreadLocalMap.slowThreadLocalMap;
        // 从JDK的ThreadLocal中获取InternalThreadLocalMap对象
        InternalThreadLocalMap ret = slowThreadLocalMap.get();
        if (ret == null) {
            ret = new InternalThreadLocalMap();
            slowThreadLocalMap.set(ret);
        }
        return ret;
    }

InternalThreadLocalMap 初始化，它会初始化一个长度为 32 的 Object 数组，数组中填充着 32 个缺省对象 UNSET 的引用。

slowGet() 是针对非 FastThreadLocalThread 类型的线程发起调用时的一种兜底方案。

如果当前线程不是 FastThreadLocalThread，内部是没有 InternalThreadLocalMap 属性的。

Netty 在 UnpaddedInternalThreadLocalMap 中保存了一个 JDK 原生的 ThreadLocal。

ThreadLocal 中存放着 InternalThreadLocalMap，此时获取 InternalThreadLocalMap 就退化成 JDK 原生的 ThreadLocal 获取

setKnownNotUnset()：

/**
     * @return see {@link InternalThreadLocalMap#setIndexedVariable(int, Object)}.
     */
    private void setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value) { 
        // 给指定的下标赋值，如果存在旧值，则直接覆盖
        if (threadLocalMap.setIndexedVariable(index, value)) {
            // 将 FastThreadLocal 对象保存到待清理的 Set 中
            addToVariablesToRemove(threadLocalMap, this);
        }
    }

threadLocalMap.setIndexedVariable()：

/**
     * @return {@code true} if and only if a new thread-local variable has been created
     */
    public boolean setIndexedVariable(int index, Object value) {
        // indexedVariables就是InternalThreadLocalMap中用于存放数据的数组
        Object[] lookup = indexedVariables;
        if (index < lookup.length) {
            Object oldValue = lookup[index];
            // 直接将数组 index 位置设置为 value，时间复杂度为 O(1)
            lookup[index] = value;
            return oldValue == UNSET;
        } else {
            // 如果容量不够，先扩容，再新增
            expandIndexedVariableTableAndSet(index, value);
            return true;
        }
    }

addToVariablesToRemove()：

private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
        // variablesToRemoveIndex, 数组下标 固定值0
        Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
        Set<FastThreadLocal<?>> variablesToRemove;
        // 逻辑是，要拿到Set<FastThreadLocal<?>>集合，如果没有就创建并塞进indexedVariable[0]中
        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);
    }

将 FastThreadLocal 对象保存到待清理的 Set 中。

这里就解释了 InternalThreadLocalMap 的 value 数据为什么是从下标为 1 的位置开始存储了，因为 0 的位置已经被 Set 集合占用了。

为什么 InternalThreadLocalMap 要在数组下标为 0 的位置存放一个 FastThreadLocal 类型的 Set 集合呢？

/**
     * Sets the value to uninitialized; a proceeding call to get() will trigger a call to initialValue().
     */
    public final void remove() {
        remove(InternalThreadLocalMap.getIfSet());
    }

    public static InternalThreadLocalMap getIfSet() {
        Thread thread = Thread.currentThread();
        if (thread instanceof FastThreadLocalThread) {
            return ((FastThreadLocalThread) thread).threadLocalMap();
        }
        return slowThreadLocalMap.get();
    }

    /**
     * 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.
     */
    public final void remove(InternalThreadLocalMap threadLocalMap) {
        if (threadLocalMap == null) {
            return;
        }
        // index是当前FastThreadLocal对应在数组中的下标位置
        // 将下标fastThreadLocal对应value置为UNSET
        Object v = threadLocalMap.removeIndexedVariable(index);
        // 删除当前FastThreadLocal对象
        removeFromVariablesToRemove(threadLocalMap, this);

        if (v != InternalThreadLocalMap.UNSET) {
            try {
                // 空操作，子类可扩展
                onRemoval((V) v);
            } catch (Exception e) {
                PlatformDependent.throwException(e);
            }
        }
    }
‍

因此 Set 集合是为了保存 FastThreadLocal对象，好处有几点：

删除 FastThreadLocal 留扩展接口
提高 removeAll 的删除效率，不需要去遍历膨胀的数组
可以更好地做内存泄露的管理

get()操作：

public final V get(InternalThreadLocalMap threadLocalMap) {
        Object v = threadLocalMap.indexedVariable(index);
        if (v != InternalThreadLocalMap.UNSET) {
            return (V) v;
        }
        // 如果获取到的数组元素是缺省对象，执行初始化操作
        return initialize(threadLocalMap);
    }

    private V initialize(InternalThreadLocalMap threadLocalMap) {
        V v = null;
        try {
            // 扩展实现, 用户可实现初始化操作
            v = initialValue();
        } catch (Exception e) {
            PlatformDependent.throwException(e);
        }

        threadLocalMap.setIndexedVariable(index, v);
        addToVariablesToRemove(threadLocalMap, this);
        return v;
    }
‍

如果能拿到对象，就直接返回，拿不到就通过 initialize 初始化对象。构造完用户对象数据之后，接下来就会将它填充到数组 index 的位置，然后再把当前 FastThreadLocal 对象保存到待清理的 Set 中。

总结

‍

对比ThreadLocal 和 FastThreadLocal，简单总结下 FastThreadLocal 的优势：

①高效查找，FastThreadLocal 通过 index 直接定位在数组中的位置，O(1) 操作；ThreadLocal 内部使用 hash+线性探测，有可能出现冲突，要往后线性查找合适的位置。

②安全性更高，JDK 原生的 ThreadLocal 使用不当可能造成内存泄漏。

而 FastThreadLocal 不仅提供了 remove() 主动清除对象的方法，而且在线程池场景中 Netty 还封装了 FastThreadLocalRunnable，FastThreadLocalRunnable 最后会执行 FastThreadLocal.removeAll() 将 Set 集合中所有 FastThreadLocal 对象都清理掉。

③更高效的扩容，FastThreadLocal 相比 ThreadLocal 数据扩容更加简单高效，FastThreadLocal 以 index 为基准向上取整到 2 的次幂作为扩容后容量，然后把原数据拷贝到新数组。

而 ThreadLocal 由于采用的哈希表，所以在扩容后需要再做一轮 rehash。

缺点：

数组 index 不会复用，会持续增长，空间消耗较大。
需要结合 FastThreadLocalThread 使用，否则也会退化成 ThreadLocal 处理。

-------------  END  -------------
扫码免费获取600+页石杉老师原创精品文章汇总PDF



原创技术文章汇总


点个在看你最好看

石杉的架构笔记

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫