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

源码分析基于Netty 4.1.52

FastThreadLocal

FastThreadLocal比较简单。

FastThreadLocal和FastThreadLocalThread是配套使用的。

FastThreadLocalThread继承了Thread,FastThreadLocalThread#threadLocalMap 是一个InternalThreadLocalMap,该InternalThreadLocalMap对象只能用于当前线程。

InternalThreadLocalMap#indexedVariables是一个数组,存放了当前线程所有FastThreadLocal对应的值。

而每个FastThreadLocal都有一个index,用于定位InternalThreadLocalMap#indexedVariables。

FastThreadLocal#get

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

#1 获取该线程的InternalThreadLocalMap

如果是FastThreadLocalThread,直接获取FastThreadLocalThread#threadLocalMap。

否则,从UnpaddedInternalThreadLocalMap.slowThreadLocalMap获取该线程InternalThreadLocalMap。

注意,UnpaddedInternalThreadLocalMap.slowThreadLocalMap是一个ThreadLocal,这里实际回退到使用ThreadLocal了。

#2 每个FastThreadLocal都有一个index。

通过该index,获取InternalThreadLocalMap#indexedVariables中存放的值

#3 找不到值,通过initialize方法构建新对象。

可以看到,FastThreadLocal中连hash算法都不用,通过下标获取对应的值,复杂度为log(1),自然很快啦。

HashedWheelTimer

HashedWheelTimer是Netty提供的时间轮调度器。

时间轮是一种充分利用线程资源进行批量化任务调度的调度模型,能够高效的管理各种延时任务。

简单说,就是将延时任务存放到一个环形队列中,并通过执行线程定时执行该队列的任务。

例如,

环形队列上有60个格子,

执行线程每秒移动一个格子,则环形队列每轮可存放1分钟内的任务。

现在有两个定时任务

task1,32秒后执行

task2,2分25秒后执行

而执行线程当前位于第6格子

则task1放到32+6=38格,轮数为0

task2放到25+6=31个,轮数为2

执行线程将执行当前格子轮数为0的任务,并将其他任务轮数减1。

缺点,时间轮调度器的时间精度不高。

因为时间轮算法的精度取决于执行线程移动速度。

例如上面例子中执行线程每秒移动一个格子,则调度精度小于一秒的任务就无法准时调用。

HashedWheelTimer关键字段

// 任务执行器,负责执行任务
Worker worker = new Worker();
// 任务执行线程
Thread workerThread;
// HashedWheelTimer状态, 0 - init, 1 - started, 2 - shut down
int workerState;
// 时间轮队列,使用数组实现
HashedWheelBucket[] wheel;
// 暂存新增的任务
Queue<HashedWheelTimeout> timeouts = PlatformDependent.newMpscQueue();
// 已取消任务
Queue<HashedWheelTimeout> cancelledTimeouts = PlatformDependent.newMpscQueue();

添加延迟任务 HashedWheelTimer#newTimeout

public Timeout newTimeout(TimerTask task, long delay, TimeUnit unit) {
... // #1
start(); // #2
long deadline = System.nanoTime() + unit.toNanos(delay) - startTime; ...
HashedWheelTimeout timeout = new HashedWheelTimeout(this, task, deadline);
timeouts.add(timeout);
return timeout;
}

#1 如果HashedWheelTimer未启动,则启动该HashedWheelTimer

HashedWheelTimer#start方法负责是启动workerThread线程

#2 startTime是HashedWheelTimer启动时间

deadline是相对HashedWheelTimer启动的延迟时间

构建HashedWheelTimeout,添加到HashedWheelTimer#timeouts

时间轮运行 Worker#run

public void run() {
... // #1
startTimeInitialized.countDown(); do {
// #2
final long deadline = waitForNextTick();
if (deadline > 0) {
// #3
int idx = (int) (tick & mask);
processCancelledTasks();
HashedWheelBucket bucket = wheel[idx];
// #4
transferTimeoutsToBuckets();
// #5
bucket.expireTimeouts(deadline);
// #6
tick++;
}
} while (WORKER_STATE_UPDATER.get(HashedWheelTimer.this) == WORKER_STATE_STARTED); // #7
...
}

#1 HashedWheelTimer#start方法阻塞HashedWheelTimer线程直到Worker启动完成,这里解除HashedWheelTimer线程阻塞。

#2 计算下一格子开始执行的时间,然后sleep到下次格子开始执行时间

#2 tick是从HashedWheelTimer启动后移动的总格子数,这里获取tick对应的格子索引。

由于Long类型足够大,这里并不考虑溢出问题。

#4 将HashedWheelTimer#timeouts的任务迁移到对应的格子中

#5 处理已到期任务

#6 移动到下一个格子

#7 这里是HashedWheelTimer#stop后的逻辑处理,取消任务,停止时间轮

迁移任务 Worker#transferTimeoutsToBuckets

private void transferTimeoutsToBuckets() {
// #1
for (int i = 0; i < 100000; i++) {
HashedWheelTimeout timeout = timeouts.poll();
if (timeout == null) {
// all processed
break;
}
if (timeout.state() == HashedWheelTimeout.ST_CANCELLED) {
continue;
}
// #2
long calculated = timeout.deadline / tickDuration;
// #3
timeout.remainingRounds = (calculated - tick) / wheel.length;
// #4
final long ticks = Math.max(calculated, tick); // Ensure we don't schedule for past.
// #5
int stopIndex = (int) (ticks & mask); HashedWheelBucket bucket = wheel[stopIndex];
bucket.addTimeout(timeout);
}
}

#1 注意,每次只迁移100000个任务,以免阻塞线程

#2 任务延迟时间/每格时间数, 得到该任务需延迟的总格子移动数

#3 (总格子移动数 - 已移动格子数)/每轮格子数,得到轮数

#4 如果任务在timeouts队列放得太久导致已经过了执行时间,则使用当前tick, 也就是放到当前bucket,以便尽快执行该任务

#5 计算tick对应格子索引,放到对应的格子位置

执行到期任务 HashedWheelBucket#expireTimeouts

public void expireTimeouts(long deadline) {
HashedWheelTimeout timeout = head; while (timeout != null) {
HashedWheelTimeout next = timeout.next;
// #1
if (timeout.remainingRounds <= 0) {
// #2
next = remove(timeout);
if (timeout.deadline <= deadline) {
// #3
timeout.expire();
} else {
throw new IllegalStateException(String.format(
"timeout.deadline (%d) > deadline (%d)", timeout.deadline, deadline));
}
} else if (timeout.isCancelled()) {
next = remove(timeout);
} else {
// #4
timeout.remainingRounds --;
}
timeout = next;
}
}

#1 选择轮数小于等于0的任务

#2 移除任务

#3 修改状态为过期,并执行任务

#4 其他任务轮数减1

ScheduledExecutorService使用堆(DelayedWorkQueue)维护任务,新增任务复杂度为O(logN)。

而 HashedWheelTimer 新增任务复杂度为O(1),所以在任务非常多时, HashedWheelTimer 可以表现出它的优势。

但是任务较少甚至没有任务时,HashedWheelTimer的执行线程都需要不断移动,也会造成性能消耗。

注意,HashedWheelTimer使用同一个线程调用和执行任务,如果某些任务执行时间过久,则影响后续定时任务执行。当然,我们也可以考虑在任务中另起线程执行逻辑。

另外,如果任务过多,也会导致任务长期滞留在HashedWheelTimer#timeouts中而不能及时执行。

如果您觉得本文不错,欢迎关注我的微信公众号,系列文章持续更新中。您的关注是我坚持的动力!

Netty源码解析 -- FastThreadLocal与HashedWheelTimer的更多相关文章

  1. Netty源码解析—客户端启动

    Netty源码解析-客户端启动 Bootstrap示例 public final class EchoClient { static final boolean SSL = System.getPro ...

  2. Netty源码解析---服务端启动

    Netty源码解析---服务端启动 一个简单的服务端代码: public class SimpleServer { public static void main(String[] args) { N ...

  3. Netty 源码解析(三): Netty 的 Future 和 Promise

    今天是猿灯塔“365篇原创计划”第三篇. 接下来的时间灯塔君持续更新Netty系列一共九篇 Netty 源码解析(一): 开始 Netty 源码解析(二): Netty 的 Channel 当前:Ne ...

  4. Netty 源码解析(九): connect 过程和 bind 过程分析

    原创申明:本文由公众号[猿灯塔]原创,转载请说明出处标注 今天是猿灯塔“365篇原创计划”第九篇. 接下来的时间灯塔君持续更新Netty系列一共九篇 Netty 源码解析(一): 开始 Netty 源 ...

  5. Netty 源码解析(八): 回到 Channel 的 register 操作

    原创申明:本文由公众号[猿灯塔]原创,转载请说明出处标注 今天是猿灯塔“365篇原创计划”第八篇. 接下来的时间灯塔君持续更新Netty系列一共九篇 Netty 源码解析(一): 开始 Netty 源 ...

  6. Netty 源码解析(七): NioEventLoop 工作流程

    原创申明:本文由公众号[猿灯塔]原创,转载请说明出处标注 今天是猿灯塔“365篇原创计划”第七篇. 接下来的时间灯塔君持续更新Netty系列一共九篇 Netty 源码解析(一): 开始 Netty 源 ...

  7. Netty 源码解析(六): Channel 的 register 操作

    原创申明:本文由公众号[猿灯塔]原创,转载请说明出处标注 今天是猿灯塔“365篇原创计划”第六篇. 接下来的时间灯塔君持续更新Netty系列一共九篇   Netty 源码解析(一 ):开始 Netty ...

  8. Netty 源码解析(五): Netty 的线程池分析

    今天是猿灯塔“365篇原创计划”第五篇. 接下来的时间灯塔君持续更新Netty系列一共九篇 Netty 源码解析(一): 开始 Netty 源码解析(二): Netty 的 Channel Netty ...

  9. Netty 源码解析(四): Netty 的 ChannelPipeline

    今天是猿灯塔“365篇原创计划”第四篇. 接下来的时间灯塔君持续更新Netty系列一共九篇 Netty 源码解析(一): 开始 Netty 源码解析(二): Netty 的 Channel Netty ...

随机推荐

  1. 验证pdf文件的电子章签名

    pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="htt ...

  2. VS2015配置海康威视工业相机SDK二次开发

    1.概述:工业相机SDK是用于控制相机的一个独立组件,支持获取实时图像数据.配置参数.对图像进行后续处理等功能.工业相机SDK兼容GigE Vision协议.USB3 Vision协议.Camera ...

  3. Spring源码分析之AOP从解析到调用

    正文: 在上一篇,我们对IOC核心部分流程已经分析完毕,相信小伙伴们有所收获,从这一篇开始,我们将会踏上新的旅程,即Spring的另一核心:AOP! 首先,为了让大家能更有效的理解AOP,先带大家过一 ...

  4. 【jenkins】构建工作集

    构建工作集,参数化工作任务 1.New Item 2.配置新的工作任务 3.关联测试用例的远程仓库 4.添加任务构建后,触发发送报告信息 5.新建单个测试套件 6.添加触发轮询任务 7.关联测试集 8 ...

  5. <UnityTheGreat><001>获取指定目录下指定类型的所有文件的名称

    #region Environment Windows 10 Unity 2019.4.16f1c1 LTS VSCode 1.52 https://github.com/MirzkisD1Ex0/U ...

  6. Greenplum 性能优化之路 --(一)分区表

    一.什么是分区表 分区表就是将一个大表在物理上分割成若干小表,并且整个过程对用户是透明的,也就是用户的所有操作仍然是作用在大表上,不需要关心数据实际上落在哪张小表里面.Greenplum 中分区表的原 ...

  7. js上 十九、综合案例

    十九.综合案例 题目一: 封装一个函数equal(a1,a2),传入两个一维数组,判断两个数组是否包含相同的元素,如果相等,函数的返回值为true, 不相等,函数的返回值为false 1)例:arr1 ...

  8. [水题日常]UVA11181 条件概率(Probability|Given)

    话说好久没写blog了 好好学概率论的第一天,这题一开始完全不会写,列出个条件概率的公式就傻了,后来看着lrj老师的书附带的代码学着写的- 因为我比较弱智 一些比较简单的东西也顺便写具体点或者是按照书 ...

  9. 【java学习笔记2】访问控制修饰符 public、protected、默认、private

    先写了一个User()类: package chapter01; public class User { // 私有的 private int id; // 受保护的 protected int ag ...

  10. 【剑指offer】03 从尾到头打印链表

    题目地址:从尾到头打印链表 题目描述                                    输入一个链表,按链表从尾到头的顺序返回一个ArrayList. 时间限制:C/C++ 1秒, ...