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 的情况。不过这种方式已经最大限度地减轻了多线程的资源竞争,提高程序效率。