谈谈FastLocal为啥这么快

最新推荐文章于 2022-08-11 16:59:23 发布

ZNineSun

最新推荐文章于 2022-08-11 16:59:23 发布

阅读量306

点赞数

分类专栏：面试 # 多线程文章标签： FastLocal ThreadLocal 线性探测 ftl ftlt

本文链接：https://blog.csdn.net/zhiyikeji/article/details/124925017

版权

面试同时被 2 个专栏收录

74 篇文章 11 订阅

订阅专栏

多线程

6 篇文章 0 订阅

订阅专栏

1.FastThreadLocal 的引入背景和原理简介

既然 jdk 已经有 ThreadLocal，为何 netty 还要自己造个 FastThreadLocal？看名字就能看出来最明显和ThreadLocal不一样的特征就是快，那么FastThreadLocal 快在哪里？

这需要从 jdk ThreadLocal 的本身说起。如下图：
在这里插入图片描述

在 java 线程中，每个线程都有一个 ThreadLocalMap 实例变量（如果不使用 ThreadLocal，不会创建这个 Map，一个线程第一次访问某个 ThreadLocal 变量时，才会创建）。

ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它命名为ThreadLocalVariable更容易让人理解一些。

它主要由四个方法组成initialValue()，get()，set(T)，remove()，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()时才执行，并且仅执行1次（即：最多在每次访问线程来获得每个线程局部变量时调用此方法一次，即线程第一次使用get()方法访问变量的时候。如果线程先于get方法调用set(T)方法，则不会在线程中再调用initialValue方法）。ThreadLocal中的缺省实现直接返回一个null：

该 Map 是使用线性探测的方式解决 hash 冲突的问题，如果没有找到空闲的 slot，就不断往后尝试，直到找到一个空闲的位置，插入 entry，这种方式在经常遇到 hash 冲突时，影响效率。

FastThreadLocal(下文简称 ftl) 直接使用数组避免了 hash 冲突的发生，具体做法是：每一个 FastThreadLocal 实例创建时，分配一个下标 index；分配 index 使用 AtomicInteger 实现，每个FastThreadLocal 都能获取到一个不重复的下标。

当调用 ftl.get() 方法获取值时，直接从数组获取返回，如 return array[index] ，如下图：
在这里插入图片描述

2.源码分析

通过上面的内容我们可以看到ftl 的实现，涉及到 InternalThreadLocalMap、FastThreadLocalThread 和 FastThreadLocal 几个类，自底向上，我们先从 InternalThreadLocalMap 开始分析。

InternalThreadLocalMap 类的继承关系图如下：
在这里插入图片描述

而UnpaddedInternalThreadLocalMap 的主要属性

static final ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = new ThreadLocal<InternalThreadLocalMap>();
static final AtomicInteger nextIndex = new AtomicInteger();
Object[] indexedVariables;

在这儿我们可以看到数组indexedVariables 就是用来存储 ftl 的value 的，使用下标的方式直接访问。nextIndex 在 ftl 实例创建时用来给每个 ftl 实例分配一个下标，slowThreadLocalMap 在线程不是 ftlt（FastThreadLocalThread ）时使用到。

2.1 InternalThreadLocalMap分析

在这里插入图片描述

里面newIndexedVariableTable() 方法创建长度为 32 的数组，然后初始化为 UNSET，然后传给父类。之后 ftl 的值就保存到这个数组里面。

注意，这里保存的直接是变量值，不是 entry，这是和 jdk ThreadLocal 不同的。

2.2 ftlt 的实现分析

要发挥 ftl 的性能优势，必须和 ftlt 结合使用，否则就会退化到 jdk 的 ThreadLocal。ftlt 比较简单，关键代码如下：

public class FastThreadLocalThread extends Thread {
  // This will be set to true if we have a chance to wrap the Runnable.
  private final boolean cleanupFastThreadLocals;

  private InternalThreadLocalMap threadLocalMap;

  public final InternalThreadLocalMap threadLocalMap() {
        return threadLocalMap;
  }
  public final void setThreadLocalMap(InternalThreadLocalMap threadLocalMap) {
        this.threadLocalMap = threadLocalMap;
  }
}

ftlt 的诀窍就在 threadLocalMap 属性，它继承 java Thread，然后聚合了自己的 InternalThreadLocalMap。后面访问 ftl 变量，对于 ftlt 线程，都直接从 InternalThreadLocalMap 获取变量值。

2.3 ftl 实现分析

ftl 实现分析基于 netty-4.1.34 版本，特别地声明了版本，是因为在清除的地方，该版本的源码已经注释掉了 ObjectCleaner 的调用，和之前的版本有所不同。

2.3.1 ftl 的属性和实例化

private final int index;

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

非常简单，就是给属性 index 赋值，赋值的静态方法在 InternalThreadLocalMap：

 public static int nextVariableIndex() {
        int index = nextIndex.getAndIncrement();
        if (index < 0) {
            nextIndex.decrementAndGet();
            throw new IllegalStateException("too many thread-local indexed variables");
        }
        return index;
  }

可见，每个 ftl 实例以步长为 1 的递增序列，获取 index 值，这保证了 InternalThreadLocalMap 中数组的长度不会突增。

2.3.2 get() 方法实现分析

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

    V value = initialize(threadLocalMap); // 3
    registerCleaner(threadLocalMap);  // 4
    return value;
}

先来看看 InternalThreadLocalMap.get() 方法如何获取 threadLocalMap：

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

  private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
        InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
        if (threadLocalMap == null) {
            thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
        }
        return threadLocalMap;
    }

因为结合 FastThreadLocalThread 使用才能发挥 FastThreadLocal 的性能优势，所以主要看 fastGet 方法。该方法直接从 ftlt 线程获取 threadLocalMap，还没有则创建一个 InternalThreadLocalMap 实例并设置进去，然后返回。

再来看看

Object v = threadLocalMap.indexedVariable(index); // 2

 public Object indexedVariable(int index) {
        Object[] lookup = indexedVariables;
        return index < lookup.length? lookup[index] : UNSET;
    }

直接从数组获取值，然后返回

如果获取到的值不是 UNSET，那么是个有效的值，直接返回。如果是 UNSET，则初始化。

initialize(threadLocalMap) 方法：

private V initialize(InternalThreadLocalMap threadLocalMap) {
        V v = null;
        try {
            v = initialValue();
        } catch (Exception e) {
            PlatformDependent.throwException(e);
        }

        threadLocalMap.setIndexedVariable(index, v); // 3-1
        addToVariablesToRemove(threadLocalMap, this); // 3-2
        return v;
    }

上面的代码经历了两个过程：

获取 ftl 的初始值，然后保存到 ftl 里的数组，如果数组长度不够则扩充数组长度，然后保存，不展开。
addToVariablesToRemove(threadLocalMap, this) 的实现，是将 ftl 实例保存在 threadLocalMap 内部数组第 0 个元素的 Set 集合中。

2.4 普通线程使用 ftl 的性能退化

ftl 要结合 ftlt 才能最大地发挥其性能，如果是其他的普通线程，就会退化到 jdk 的 ThreadLocal 的情况，因为普通线程没有包含 InternalThreadLocalMap 这样的数据结构，接下来我们看如何退化。
从 InternalThreadLocalMap 的 get() 方法看起：

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

  private static InternalThreadLocalMap slowGet() {
       // 父类的类型为jdk ThreadLocald的静态属性，从该threadLocal获取InternalThreadLocalMap
        ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = UnpaddedInternalThreadLocalMap.slowThreadLocalMap;
        InternalThreadLocalMap ret = slowThreadLocalMap.get();
        if (ret == null) {
            ret = new InternalThreadLocalMap();
            slowThreadLocalMap.set(ret);
        }
        return ret;
    }

从 ftl 看，退化操作的整个流程是：从一个 jdk 的 ThreadLocal 变量中获取 InternalThreadLocalMap，然后再从 InternalThreadLocalMap 获取指定数组下标的值，对象关系示意图：
在这里插入图片描述

3 ftl 的资源回收机制

在 netty 中对于 ftl 提供了三种回收机制：

自动：使用 ftlt 执行一个被 FastThreadLocalRunnable wrap 的 Runnable 任务，在任务执行完毕后会自动进行 ftl 的清理。
手动：ftl 和 InternalThreadLocalMap 都提供了 remove 方法，在合适的时候用户可以（有的时候也是必须，例如普通线程的线程池使用 ftl）手动进行调用，进行显示删除。
自动：为当前线程的每一个 ftl 注册一个 Cleaner，当线程对象不强可达的时候，该 Cleaner 线程会将当前线程的当前 ftl 进行回收。（netty 推荐如果可以用其他两种方式，就不要再用这种方式，因为需要另起线程，耗费资源，而且多线程就会造成一些资源竞争，在 netty-4.1.34 版本中，已经注释掉了调用 ObjectCleaner 的代码。）

4 ftl 在 netty 中的使用

ftl 在 netty 中最重要的使用，就是分配 ByteBuf。

基本做法是：每个线程都分配一块内存 (PoolArena)，当需要分配 ByteBuf 时，线程先从自己持有的 PoolArena 分配，如果自己无法分配，再采用全局分配。

但是由于内存资源有限，所以还是会有多个线程持有同一块 PoolArea 的情况。不过这种方式已经最大限度地减轻了多线程的资源竞争，提高程序效率。

ZNineSun

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
谈谈FastLocal为啥这么快

1.FastThreadLocal 的引入背景和原理简介既然 jdk 已经有 ThreadLocal，为何 netty 还要自己造个 FastThreadLocal？看名字就能看出来最明显和ThreadLocal不一样的特征就是快，那么FastThreadLocal 快在哪里？这需要从 jdk ThreadLocal 的本身说起。如下图：在 java 线程中，每个线程都有一个 ThreadLocalMap 实例变量（如果不使用 ThreadLocal，不会创建这个 Map，一个线程第一次访问某个 T
复制链接

扫一扫