上节讲过了ThreadLocal的源码,这一节我们来看下FastThreadLocal。这个我觉得要比ThreadLocal要简单,因为缺少了对于Entry的清理和整理工作,所以ThreadLocal的效率更高。

跟ThreadLocal一样,我们也先给一个结构图:

大家看这个图跟ThreadLocal有哪些区别,首先是用一个Object数组来替代了Entry数组,不再是key键值对的形式。 另外Object[0]存储一个Set<FastThreadLocal<?>>集合。

OK,看完这个,源码就很好理解了,我们还是先看下 InternalThreadLocalMap 构造函数

     private InternalThreadLocalMap() {
super(newIndexedVariableTable());
} private static Object[] newIndexedVariableTable() {
Object[] array = new Object[32]; //初始化 32 长度的Object数组
Arrays.fill(array, UNSET); // 将每个元素初始化成UNSET 这里的UNSET 可以理解为占位符, 因为null会被认为成有效值
return array;
}
10    UnpaddedInternalThreadLocalMap(Object[] indexedVariables) {
11 this.indexedVariables = indexedVariables; // 将创建的array赋给 Object[] indexedVariables;
12 }

看完这个,我们来看下数组的索引值是什么设置的,打开  FastThreadLocal, 看下全局变量。

 private static final int variablesToRemoveIndex = InternalThreadLocalMap.nextVariableIndex();

上面这个了解类的加载机制的应该很清楚 variablesToRemoveIndex  初始化的时机。想要了解类的加载过程的 请移步类的加载机制(一)

     static final AtomicInteger nextIndex = new AtomicInteger(); // 原子类

     public static int nextVariableIndex() {
int index = nextIndex.getAndIncrement(); // 先获取值,在增加,所以index = 0
if (index < 0) {
nextIndex.decrementAndGet();
throw new IllegalStateException("too many thread-local indexed variables");
}
return index;
}

由此得出,variablesToRemoveIndex  = 0 固定值。再看下 FastThreadLocal 的构造方法

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

大家看到这个,是不是就想到了,也就是说每个 FastThreadLocal 都有一个唯一的 index 值 , 那么跟ThreadLocal相比的话,ThreadLocal要 先获取一个hash值,然后再根据Entry数组的长度进行运算得到一个索引值,所以说这样也是Netty的这个FastThreadLocal效率更高的原因之一。

为了更好地讲下面的内容,我们再看一个 FastThreadLocalThread

继承了Thread,增加了成员变量 InternalThreadLocalMap threadLocalMap.  不再是放在Thread中的成员变量了,看到这个想到了什么? 那么也就是说获取某个线程存储Object数组结构的Map,是从FastThreadLocalThread中获取。

好了介绍完上面,看set方法

     public final void set(V value) {
if (value != InternalThreadLocalMap.UNSET) { // 如果不是UNSET
InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get(); // 获取map
if (setKnownNotUnset(threadLocalMap, value)) { // 新增或者更新值
registerCleaner(threadLocalMap); // 如果返回true, 代表新增, 设置清理位
}
} else {
remove(); // 如果入参是一个UNSET,那么执行删除逻辑
}
}

看下 InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();

     public static InternalThreadLocalMap get() {
Thread thread = Thread.currentThread();
if (thread instanceof FastThreadLocalThread) { // 如果当前线程是一个FastThreadLocalThread
return fastGet((FastThreadLocalThread) thread); // 执行fastGet 这个名字是很有意思。。。。
} else {
return slowGet(); // 要不然就slowGet() Netty叫ThreadLocal Slow。。。
}
}
     private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) { // 如果当前的map没有设置,则新创建一个
InternalThreadLocalMap threadLocalMap = thread.threadLocalMap(); // 这里就是获取了 FastThreadLocalThread 中的成员变量 threadLocalMap
if (threadLocalMap == null) {
thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
}
return threadLocalMap;
}

看下新增或者更新的逻辑

     private boolean setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value) {
if (threadLocalMap.setIndexedVariable(index, value)) { // index 是当前FastThreadLocal的索引 ,如果是 新增,那么这个方法返回true ,如果是修改则返回 false
addToVariablesToRemove(threadLocalMap, this); // 新增的话,需要将当前的这个FastThreadLocal添加到Set<FashThreadLocal>集合中
return true; // 新增返回trye
}
return false; // 更新返回false
}
     public boolean setIndexedVariable(int index, Object value) {
Object[] lookup = indexedVariables; // 当前的Object[]对象
if (index < lookup.length) { // 检查当前的索引是否超过了Object数组的长度
Object oldValue = lookup[index]; // 获取当前的值
lookup[index] = value; // 将新值设置进去
return oldValue == UNSET; // 判断之前的值是不是占位符,如果是则代表新增,不是代表更新
} else {
expandIndexedVariableTableAndSet(index, value); // 如果超过了,则需要进行扩容
return true;
}
}
     private void expandIndexedVariableTableAndSet(int index, Object value) { // 扩容逻辑
Object[] oldArray = indexedVariables; // 当前的Object数组
final int oldCapacity = oldArray.length; // 当前的长度
int newCapacity = index; // index是这个FastThreadLocal对应的索引值
newCapacity |= newCapacity >>> 1;
newCapacity |= newCapacity >>> 2;
newCapacity |= newCapacity >>> 4;
newCapacity |= newCapacity >>> 8;
newCapacity |= newCapacity >>> 16;
newCapacity ++; // 这段其实也很有意思,其实是为了计算新的数组的容量,会变成下一个档位的2的次方大小,比如 1->2 2->4 3->4 4->8 5->8 6->8 7->8 8->16 18->32, 如果不理解,
// 可以自己写一个main方法试一下,后面我们在讲Netty内存模型的时候大家也会看到这么一段。 Object[] newArray = Arrays.copyOf(oldArray, newCapacity); // 将老的数据往新的数组进行拷贝
Arrays.fill(newArray, oldCapacity, newArray.length, UNSET); // 将新的多出来的部分,设置占位符
newArray[index] = value; // 将index对应的值设置完
indexedVariables = newArray; // 将新的数组提升成Map中的indexedVariables
}

接下来看下set中的这句 addToVariablesToRemove(threadLocalMap, this);  根据上面的结构,新增了value,那么就需要修改set集合

     private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex); // 根据上面的分析 variablesToRemoveIndex = 0 获取第0个位置的Object 然后看是不是null或者占位符
Set<FastThreadLocal<?>> variablesToRemove;
if (v == InternalThreadLocalMap.UNSET || v == null) { // 如果是占位符
variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());
threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove); // 创建一个set集合放到第0的位置上
} else {
variablesToRemove = (Set<FastThreadLocal<?>>) v; // 已经有了,则直接取过来
} variablesToRemove.add(variable); // 新增新的FastThreadLocal到set集合
}

接下来看get方法

     public final V get() {
InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get(); // 获取map
Object v = threadLocalMap.indexedVariable(index); // 根据当前的Thread的索引,获取Object
if (v != InternalThreadLocalMap.UNSET) { // 不是占位符直接返回
return (V) v;
} V value = initialize(threadLocalMap); // 如果是,则调用初始化方法
registerCleaner(threadLocalMap);
return value;
}
     private V initialize(InternalThreadLocalMap threadLocalMap) {
V v = null;
try {
v = initialValue(); // 空方法,供子类调用
} catch (Exception e) {
PlatformDependent.throwException(e);
} threadLocalMap.setIndexedVariable(index, v); // 设置初始化的值
addToVariablesToRemove(threadLocalMap, this); // 添加set集合
return v;
}

接下来看remove方法

     public final void remove(InternalThreadLocalMap threadLocalMap) {
if (threadLocalMap == null) {
return;
} Object v = threadLocalMap.removeIndexedVariable(index); // 根据当前的Thread的索引,获取Object
removeFromVariablesToRemove(threadLocalMap, this); // 移除set集合中的元素,这里就不展开说了,上面懂了就很简单了 if (v != InternalThreadLocalMap.UNSET) {
try {
onRemoval((V) v); // 空方法,供子类调用
} catch (Exception e) {
PlatformDependent.throwException(e);
}
}
}

好了,这就算是讲完了,当然FastThreadLocal 不会整理数据和清除过期数据,是怎么防止内存泄露的呢?

看下 FastThreadLocalRunnable

 public class FastThreadLocalRunnable implements Runnable {
private Runnable runnable; public FastThreadLocalRunnable(Runnable runnable) {
this.runnable = ObjectUtil.checkNotNull(runnable, "runnable");
} public static Runnable wrap(Runnable runnable) {
return runnable instanceof FastThreadLocalRunnable ? runnable : new FastThreadLocalRunnable(runnable);
} @Override
public void run() {
try {
// 运行任务
this.runnable.run();
} finally {
/**
* 线程池中的线程由于会被复用,所以线程池中的每一条线程在执行task结束后,要清理掉其InternalThreadLocalMap和其内的FastThreadLocal信息,
* 否则,当这条线程在下一次被复用的时候,其ThreadLocalMap信息还存储着上一次被使用时的信息;
* 另外,假设这条线程不再被使用,但是这个线程有可能不会被销毁(与线程池的类型和配置相关),那么其上的ThreadLocal将发生资源泄露。
*/
FastThreadLocal.removeAll();
}
}
}

使用该类将一个普通的Runnable对象进行wrap装饰,之后在调用FastThreadLocalRunnable.run()的时候,实际上会调用真实对象(即普通的Runnable对象)的run(),执行完成之后,会进行对当前线程的全量回收操作(删除当前线程上的InternalThreadLocalMap中的每一个value以及threadLocalMap本身),这样就可以有效的在线程池中复用当前线程而不必关心ftl的错乱和泄漏问题。

Netty源码分析-- FastThreadLocal分析(十)的更多相关文章

  1. Netty源码解析 -- FastThreadLocal与HashedWheelTimer

    Netty源码分析系列文章已接近尾声,本文再来分析Netty中两个常见组件:FastThreadLoca与HashedWheelTimer. 源码分析基于Netty 4.1.52 FastThread ...

  2. Netty源码分析第8章(高性能工具类FastThreadLocal和Recycler)---->第1节: FastThreadLocal的使用和创建

    Netty源码分析第八章: 高性能工具类FastThreadLocal和Recycler 概述: FastThreadLocal我们在剖析堆外内存分配的时候简单介绍过, 它类似于JDK的ThreadL ...

  3. Netty源码分析第8章(高性能工具类FastThreadLocal和Recycler)---->第2节: FastThreadLocal的set方法

    Netty源码分析第八章: 高性能工具类FastThreadLocal和Recycler 第二节: FastThreadLocal的set方法 上一小节我们学习了FastThreadLocal的创建和 ...

  4. Netty源码分析第8章(高性能工具类FastThreadLocal和Recycler)---->第3节: recycler的使用和创建

    Netty源码分析第八章: 高性能工具类FastThreadLocal和Recycler 第三节: recycler的使用和创建   这一小节开始学习recycler相关的知识, recycler是n ...

  5. Netty源码分析第8章(高性能工具类FastThreadLocal和Recycler)---->第4节: recycler中获取对象

    Netty源码分析第八章: 高性能工具类FastThreadLocal和Recycler 第四节: recycler中获取对象 这一小节剖析如何从对象回收站中获取对象: 我们回顾上一小节demo的ma ...

  6. Netty源码分析第8章(高性能工具类FastThreadLocal和Recycler)---->第5节: 同线程回收对象

    Netty源码分析第八章: 高性能工具类FastThreadLocal和Recycler 第五节: 同线程回收对象 上一小节剖析了从recycler中获取一个对象, 这一小节分析在创建和回收是同线程的 ...

  7. Netty源码分析第8章(高性能工具类FastThreadLocal和Recycler)---->第6节: 异线程回收对象

    Netty源码分析第八章: 高性能工具类FastThreadLocal和Recycler 第六节: 异线程回收对象 异线程回收对象, 就是创建对象和回收对象不在同一条线程的情况下, 对象回收的逻辑 我 ...

  8. Netty源码分析第8章(高性能工具类FastThreadLocal和Recycler)---->第7节: 获取异线程释放的对象

    Netty源码分析第八章: 高性能工具类FastThreadLocal和Recycler 第七节: 获取异线程释放的对象 上一小节分析了异线程回收对象, 原理是通过与stack关联的WeakOrder ...

  9. netty源码分析(十八)Netty底层架构系统总结与应用实践

    一个EventLoopGroup当中会包含一个或多个EventLoop. 一个EventLoop在它的整个生命周期当中都只会与唯一一个Thread进行绑定. 所有由EventLoop所处理的各种I/O ...

  10. Netty源码分析(前言, 概述及目录)

    Netty源码分析(完整版) 前言 前段时间公司准备改造redis的客户端, 原生的客户端是阻塞式链接, 并且链接池初始化的链接数并不高, 高并发场景会有获取不到连接的尴尬, 所以考虑了用netty长 ...

随机推荐

  1. Windows 命令行文本操作

    Windows下文件操作,大部分的时候用的都是用Windows 资源管理器(就是双击 “我的电脑” 的时候看到的图形界面). 接下来,以Windows命令行下操作文本为例,看看命令行在操作文件方面有多 ...

  2. Python基础(九) 常用模块汇总

    3.8 json模块重点 json模块是将满足条件的数据结构转化成特殊的字符串,并且也可以反序列化还原回去. 不同语言都遵循的一种数据转化格式,即不同语言都使用的特殊字符串.(比如Python的一个列 ...

  3. sys_init

    #!/bin/bash yum install -y wget && \ wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyu ...

  4. 基于百度云的OCR识别(Python)

    2019年7月3日早上,在百度AI开发者大会上,一个来自山西的青年,将一瓶矿泉水浇在了同样来自山西的李彦宏身上. 可以回顾一下 https://b23.tv/av57665929/p1 ,着实让人一惊 ...

  5. jquery.cookie.js 获取不到cookie的值

    最近使用$.cookie获取cookie 的值.发现完全取不到.看了浏览器里也存了对应的值.可以添加,但是就是取不到., 折腾了半天,后来突然想起来加了个有可能带汉字的cookie键值.删掉就可以取出 ...

  6. Smobiler实现手机弹窗

    前言 在实际项目中有很多场景需要用到弹窗,如图1 那么这些弹窗在Smobiler中如何实现呢? 正文 Smobiler实现弹窗有两种方式:1.MessageBox.Show 2.ShowDialog和 ...

  7. asyncio源码分析之基本执行流程

    基于async关键字的原生协程 # 定义一个简单的原生协程cor async def cor(): print('enter cor') print('exit cor') print(type(co ...

  8. HDU 1533:Going Home(KM算法求二分图最小权匹配)

    http://acm.hdu.edu.cn/showproblem.php?pid=1533 Going Home Problem Description   On a grid map there ...

  9. Spring Bean 生命周期之destroy——终极信仰

    上一篇文章 Spring Bean 生命周期之我从哪里来 说明了我是谁? 和 我从哪里来? 的两大哲学问题,今天我们要讨论一下终极哲学我要到哪里去? 初始化 Spring Bean 有三种方式: @P ...

  10. c++稍微复杂桶排序(未完待续~)

    由于上次的桶排序占用空间太多,这次又有了一个新的办法 直接上代码: #include <bits/stdc++.h> using namespace std; int n; void bu ...