聚合国内IT技术精华文章,分享IT技术精华,帮助IT从业人士成长

Netty的FastThreadLocal到底有多快?

2022-06-08 10:50 浏览: 1305 次 我要评论(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(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条评论, 我也要评论

发表评论

*

* (保密)

Ctrl+Enter 快捷回复