一、工夫轮简介
1.1 为什么要应用工夫轮
在平时开发中，常常会与定时工作打交道。上面举几个定时工作解决的例子。
1）心跳检测。在Dubbo中，须要有心跳机制来维持Consumer与Provider的长连贯，默认的心跳距离是60s。当Provider在3次心跳工夫内没有收到心跳响应，会敞开连贯通道。当Consumer在3次心跳工夫内没有收到心跳响应，会进行重连。Provider侧和Consumer侧的心跳检测机制都是通过定时工作实现的，而且是本篇文章要剖析的工夫轮HashedWheelTimer解决的。
2）超时解决。在Dubbo中发动RPC调用时，通常会配置超时工夫，当消费者调用服务提供者呈现超时进行肯定的逻辑解决。那么怎么检测工作调用超时了呢？咱们能够利用定时工作，每次创立一个Future，记录这个Future的创立工夫与超时工夫，后盾有一个定时工作进行检测，当Future达到超时工夫并且没有被解决时，就须要对这个Future执行超时逻辑解决。
3）Redisson分布式锁续期。在分布式锁解决中，通常会指定分布式锁的超时工夫，同样会在finally块里开释分布式锁。然而有一个问题时，通常分布式锁的超时工夫不好判断，如果设置短了业务却没执行实现就把锁开释掉了，或者超时工夫设置很长，同样也会存在一些问题。Redisson提供了一种看门狗机制，通过工夫轮定时给分布式锁续期，也就是缩短分布式锁的超时工夫。
能够看到，上述几个例子都与定时工作无关，那么传统的定时工作有什么毛病呢？为什么要应用工夫轮来实现？
如果应用一般的定时工作解决机制来解决例2）中的超时状况：
1）简略地，能够针对每一次申请创立一个线程，而后Sleep到超时工夫，之后若判断超时则进行超时逻辑解决。存在的问题是如果面临是高并发申请，针对每个申请都要去创立线程，这样太消耗资源了。
2）针对计划1的有余，能够改成一个线程来解决所有的定时工作，比方这个线程能够每隔50ms扫描所有须要解决的超时工作，如果发现有超时工作，则进行解决。然而，这样也存在一个问题，可能一段时间内都没有工作达到超时工夫，那么就让CPU多了很多无用的轮询遍历操作。
针对上述计划的有余，能够采纳工夫轮来进行解决。上面先来简略介绍下工夫轮的概念。
1.2 单层工夫轮
咱们先以单层工夫轮为例，假如工夫轮的周期是1秒，工夫轮中有10个槽位，则每个槽位代表100ms。假如咱们当初有3个工作，别离是工作A（220ms后执行）、B（410ms之后运行）、C（1930ms之后运行）。则这三个工作在工夫轮所处的槽位如下图，能够看到工作A被放到了槽位2，工作B被放到了槽位4，工作C被放到了槽位9。
当工夫轮转动到对应的槽时，就会从槽中取出工作判断是否须要执行。同时能够发现有一个残余周期的概念，这是因为工作C的执行工夫为1930ms，超过了工夫轮的周期1秒，所以能够标记它的残余周期为1，当工夫轮第一次转动到它的地位时，发现它的残余周期为1，示意还没有到要解决的工夫，将残余周期减1，工夫轮持续转动，当下一次转动到C工作地位时，发现残余周期为0，示意工夫到了须要解决该定时工作了。Dubbo中采纳的就是这种单层工夫轮机制。
1.3 多层工夫轮
既然有单层工夫轮，那么自然而然能够想到利用多层工夫轮来解决上述工作执行工夫超出工夫轮周期的状况。上面以两层工夫轮为例，第一层工夫轮周期为1秒，第二层工夫轮周期为10秒。
还是以上述3个工作为例，能够看到工作A和B散布在第一层工夫轮上，而工作C散布在第二层工夫轮的槽1处。当第一层工夫轮转动时，工作A和工作B会被先后执行。1秒钟之后，第一层工夫轮实现了一个周期转动。从新开始第0跳，这时第二层工夫轮从槽0跳到了槽1处，将槽1处的工作，也就是工作C取出放入到第一层工夫轮的槽位9处，当第一层工夫轮转动到槽位9处，工作C就会被执行。这种将第二层的工作取出放入第一层中称为降级，它是为了保障工作被解决的工夫精度。Kafka外部就是采纳的这种多层工夫轮机制。
二、工夫轮原理
上面先来看一下Dubbo中的工夫轮的构造，能够看到，它和时钟很像，它被划分成了一个个Bucket，每个Bucket有一个头指针和尾指针，别离指向双向链表的头节点和尾节点，双向链表中存储的就是要解决的工作。工夫轮不停转动，当指向Bucket0所负责保护的双向链表时，就将它所存储的工作遍历取出来解决。
上面咱们先来介绍下Dubbo中工夫轮HashedWheelTimer所波及到的一些外围概念，在解说完这些外围概念之后，再来对工夫轮的源码进行剖析。
2.1 TimerTask
在Dubbo中，TimerTask封装了要执行的工作，它就是上图双向链表中节点所封装的工作。所有的定时工作都须要继承TimerTask接口。如下图，能够看到Dubbo中的心跳工作HeartBeatTask、注册失败重试工作FailRegisteredTask等都实现了TimerTask接口。
public interface TimerTask { void run(Timeout timeout) throws Exception;}2.2 Timeout
TimerTask中run办法的入参是Timeout，Timeout与TimerTask一一对应，Timeout的惟一实现类HashedWheelTimeout中就封装了TimerTask属性，能够了解为HashedWheelTimeout就是上述双向链表的一个节点，因而它也蕴含两个HashedWheelTimeout类型的指针，别离指向以后节点的上一个节点和下一个节点。
public interface Timeout { // Timer就是定时器, 也就是Dubbo中的工夫轮 Timer timer(); // 获取该节点要执行的工作 TimerTask task(); // 判断该节点封装的工作有没有过期、被勾销 boolean isExpired(); boolean isCancelled(); // 勾销该节点的工作 boolean cancel();}HashedWheelTimeout是Timeout的惟一实现，它的作用有两个：
- 它是工夫轮槽所保护的双向链表的节点，其中封装了理论要执行的工作TimerTask。
- 通过它能够查看定时工作的状态、对定时工作进行勾销、从双向链表中移除等操作。
上面来看一下Timeout的实现类HashedWheelTimeout的外围字段与实现。
1) int ST_INIT = 0、int ST_CANCELLED = 1、int ST_EXPIRED = 2 HashedWheelTimeout里定义了三种状态，别离示意工作的初始化状态、被勾销状态、已过期状态 2) STATE_UPDATER 用于更新定时工作的状态 3) HashedWheelTimer timer 指向工夫轮对象 4) TimerTask task 理论要执行的工作 5) long deadline 指定时工作执行的工夫，这个工夫是在创立 HashedWheelTimeout 时指定的 计算公式是: currentTime(创立 HashedWheelTimeout 的工夫) + delay(工作延迟时间) - startTime(HashedWheelTimer 的启动工夫)，工夫单位为纳秒 6) int state = ST_INIT 工作初始状态 7) long remainingRounds 指当前任务残余的时钟周期数. 工夫轮所能示意的工夫长度是无限的， 在工作到期工夫与以后时刻 的时间差超过工夫轮单圈能示意的时长，就呈现了套圈的状况，须要该字段值示意残余的时钟周期 8) HashedWheelTimeout next、HashedWheelTimeout prev 别离对应以后定时工作在链表中的前驱节点和后继节点，这也验证了工夫轮中每个槽所对应的工作链表是 一个双链表 9) HashedWheelBucket bucket 工夫轮中的一个槽，对应工夫轮圆圈的一个个小格子，每个槽保护一个双向链表，当工夫轮指针转到以后 槽时，就会从槽所负责的双向链表中取出工作进行解决HashedWheelTimeout提供了remove操作，能够从双向链表中移除以后本身节点，并将以后工夫轮所保护的定时工作数量减一。
void remove() { // 获取当前任务属于哪个槽 HashedWheelBucket bucket = this.bucket; if (bucket != null) { // 从槽中移除本人，也就是从双向链表中移除节点， // 剖析bucket的办法时会剖析 bucket.remove(this); } else { // pendingTimeouts示意以后工夫轮所保护的定时工作的数量 timer.pendingTimeouts.decrementAndGet(); }}HashedWheelTimeout提供了cancel操作，能够勾销工夫轮中的定时工作。当定时工作被勾销时，它会首先被暂存到canceledTimeouts队列中。在工夫轮转动到槽进行工作解决之前和工夫轮退出运行时都会调用cancel，而cancel会调用remove，从而清理该队列中被勾销的定时工作。
@Overridepublic boolean cancel() { // 通过CAS进行状态变更 if (!compareAndSetState(ST_INIT, ST_CANCELLED)) { return false; } // 工作被勾销时，工夫轮会将它暂存到工夫轮所保护的canceledTimeouts队列中. // 在工夫轮转动到槽进行工作解决之前和工夫轮退出运行时都会调用cancel，而 // cancel会调用remove，从而清理该队列中被勾销的定时工作 timer.cancelledTimeouts.add(this); return true;}HashedWheelTimeout提供了expire操作，当工夫轮指针转动到某个槽时，会遍历该槽所保护的双向链表，判断节点的状态，如果发现工作已到期，会通过remove办法移除，而后调用expire办法执行该定时工作。
public void expire() { // 批改定时工作状态为已过期 if (!compareAndSetState(ST_INIT, ST_EXPIRED)) { return; } try { // 真正的执行定时工作所要代表的逻辑 task.run(this); } catch (Throwable t) { // 打印日志，能够看到当工夫轮中定时工作执行异样时， // 不会抛出异样，影响到工夫轮中其余定时工作执行 }}2.3 HashedWheelBucket
后面也介绍过了，它是工夫轮中的槽，它外部保护了双向链表的首尾指针。上面咱们来看一下它外部的外围资源和实现。
1) HashedWheelTimeout head、HashedWheelTimeout tail 指向该槽所保护的双向链表的首节点和尾节点HashedWheelBucket提供了addTimeout办法，用于增加工作到双向链表的尾节点。
void addTimeout(HashedWheelTimeout timeout) { // 增加之前判断一下该工作以后没有被被关联到一个槽上 assert timeout.bucket == null; timeout.bucket = this; if (head == null) { head = tail = timeout; } else { tail.next = timeout; timeout.prev = tail; tail = timeout; }}HashedWheelBucket提供了remove办法，用于从双向链表中删除指定节点。外围逻辑如下图所示，依据要删除的节点找到其前置节点和后置节点，而后别离调整前置节点的next指针和后置节点的prev指针。删除过程中须要思考一些边界状况。删除之后将pendingTimeouts，也就是以后工夫轮的待处理工作数减一。remove代码逻辑较简略，这边就不贴代码了。
HashedWheelBucket提供了expireTimeouts办法，当工夫轮指针转动到某个槽时，通过该办法解决该槽上双向链表的定时工作，分为3种状况：
- 定时工作已到期，则会通过remove办法取出，并调用其expire办法执行工作逻辑。
- 定时工作已被勾销，则通过remove办法取出间接抛弃。
- 定时工作还未到期，则会将remainingRounds（残余时钟周期）减一。
void expireTimeouts(long deadline) { HashedWheelTimeout timeout = head; // 工夫轮指针转到某个槽时从双向链表头节点开始遍历 while (timeout != null) { HashedWheelTimeout next = timeout.next; // remainingRounds <= 0示意到期了 if (timeout.remainingRounds <= 0) { // 从链表中移除该节点 next = remove(timeout); // 判断该定时工作的确是到期了 if (timeout.deadline <= deadline) { // 执行该工作 timeout.expire(); } else { // 抛异样 } } else if (timeout.isCancelled()) { // 工作被勾销，移除后间接抛弃 next = remove(timeout); } else { // 残余时钟周期减一 timeout.remainingRounds--; } // 持续判断下一个工作节点 timeout = next; }}HashedWheelBucket也提供了clearTimeouts办法，该办法会在工夫轮进行的时候被应用，它会遍历并移除所有双向链表中的节点，并返回所有未超时和未被勾销的工作。
2.4 Worker
Worker实现了Runnable接口，工夫轮外部通过Worker线程来解决放入工夫轮中的定时工作。上面先来看一下它的外围字段和run办法逻辑。
1) Set<Timeout> unprocessedTimeouts 当工夫轮进行时，用于寄存工夫轮中未过期的和未被勾销的工作 2) long tick 工夫轮指针，指向工夫轮中某个槽，当工夫轮转动时该tick会自增public void run() { // 初始化startTime, 所有工作的的deadline都是绝对于这个工夫点 startTime = System.nanoTime(); // 唤醒阻塞在start()的线程 startTimeInitialized.countDown(); // 只有工夫轮的状态为WORKER_STATE_STARTED, 就循环的转动tick, // 解决槽中的定时工作 do { // 判断是否到了解决槽的工夫了，还没到则sleep一会 final long deadline = waitForNextTick(); if (deadline > 0) { // 获取tick对应的槽索引 int idx = (int) (tick & mask); // 清理用户被动勾销的定时工作, 这些定时工作在用户勾销时, // 会记录到 cancelledTimeouts 队列中. 在每次指针转动 // 的时候,工夫轮都会清理该队列 processCancelledTasks(); // 依据以后指针定位对应槽 HashedWheelBucket bucket = wheel[idx]; // 将缓存在 timeouts 队列中的定时工作转移到工夫轮中对应的槽中 transferTimeoutsToBuckets(); // 解决该槽位的双向链表中的定时工作 bucket.expireTimeouts(deadline); tick++; } // 检测时间轮的状态, 如果工夫轮处于运行状态, 则循环执行上述步骤, // 一直执行定时工作 } while (WORKER_STATE_UPDATER.get(HashedWheelTimer.this) == WORKER_STATE_STARTED); // 这里应该是工夫轮进行了, 革除所有槽中的工作, 并退出到未解决工作列表, // 以供stop()办法返回 for (HashedWheelBucket bucket : wheel) { bucket.clearTimeouts(unprocessedTimeouts); } // 将还没有退出到槽中的待处理定时工作队列中的工作取出, 如果是未勾销 // 的工作, 则退出到未解决工作队列中, 以供stop()办法返回 for (; ; ) { HashedWheelTimeout timeout = timeouts.poll(); if (timeout == null) { break; } if (!timeout.isCancelled()) { unprocessedTimeouts.add(timeout); } } // 最初再次清理 cancelledTimeouts 队列中用户被动勾销的定时工作 processCancelledTasks();}上面对run办法中波及到的一些办法进行介绍：
1）waitForNextTick
逻辑比较简单，它会判断有没有达到解决下一个槽工作的工夫了，如果还没有达到则sleep一会。
2）processCancelledTasks
遍历cancelledTimeouts，获取被勾销的工作并从双向链表中移除。
private void processCancelledTasks() { for (; ; ) { HashedWheelTimeout timeout = cancelledTimeouts.poll(); if (timeout == null) { // all processed break; } timeout.remove(); }}3）transferTimeoutsToBuckets
当调用newTimeout办法时，会先将要解决的工作缓存到timeouts队列中，等工夫轮指针转动时对立调用transferTimeoutsToBuckets办法解决，将工作转移到指定的槽对应的双向链表中，每次转移10万个，免得阻塞工夫轮线程。
private void transferTimeoutsToBuckets() { // 每次tick只解决10w个工作, 免得阻塞worker线程 for (int i = 0; i < 100000; i++) { HashedWheelTimeout timeout = timeouts.poll(); // 没有工作了间接跳出循环 if (timeout == null) { // all processed break; } // 还没有放入到槽中就勾销了, 间接略过 if (timeout.state() == HashedWheelTimeout.ST_CANCELLED) { continue; } // 计算工作须要通过多少个tick long calculated = timeout.deadline / tickDuration; // 计算工作的轮数 timeout.remainingRounds = (calculated - tick) / wheel.length; // 如果工作在timeouts队列外面放久了, 以至于曾经过了执行工夫, 这个时候 // 就应用以后tick, 也就是放到以后bucket, 此办法调用完后就会被执行. final long ticks = Math.max(calculated, tick); int stopIndex = (int) (ticks & mask); // 将工作退出到相应的槽中 HashedWheelBucket bucket = wheel[stopIndex]; bucket.addTimeout(timeout); }}2.5 HashedWheelTimer
最初，咱们来剖析工夫轮HashedWheelTimer，它实现了Timer接口，提供了newTimeout办法能够向工夫轮中增加定时工作，该工作会先被暂存到timeouts队列中，等工夫轮转动到某个槽时，会将该timeouts队列中的工作转移到某个槽所负责的双向链表中。它还提供了stop办法用于终止工夫轮，该办法会返回工夫轮中未解决的工作。它也提供了isStop办法用于判断工夫轮是否终止了。
先来看一下HashedWheelTimer的外围字段。
1) HashedWheelBucket[] wheel 该数组就是工夫轮的环形队列，数组每个元素都是一个槽，一个槽负责保护一个双向链表，用于存储定时 工作。它会被在构造函数中初始化，当指定为n时，它实际上会取最靠近n的且为2的幂次方值。 2) Queue<HashedWheelTimeout> timeouts timeouts用于缓存内部向工夫轮提交的定时工作 3) Queue<HashedWheelTimeout> cancelledTimeouts cancelledTimeouts用于暂存被勾销的定时工作，工夫轮会在解决槽负责的双向链表之前，先解决这两 个队列中的数据。 4) Worker worker 工夫轮解决定时工作的逻辑 5) Thread workerThread 工夫轮解决定时工作的线程 6) AtomicLong pendingTimeouts 工夫轮残余的待处理的定时工作数量 7) long tickDuration 工夫轮每个槽所代表的工夫长度 8) int workerState 工夫轮状态，可选值有init、started、shut down上面来看一下工夫轮的构造函数，用于初始化一个工夫轮。首先它会对传入参数ticksPerWheel进行转换解决，返回大于该值的2的幂次方，它示意工夫轮上有多少个槽，默认是512个。而后创立大小为该值的HashedWheelBucket[]数组。接着通过传入的tickDuration对工夫轮的tickDuration赋值，默认是100ms。节通过threadFactory创立workerThread工作线程，该线程就是负责解决工夫轮中的定时工作的线程。
public HashedWheelTimer(ThreadFactory threadFactory, long tickDuration, TimeUnit unit, int ticksPerWheel, long maxPendingTimeouts) { // 圆环上一共有多少个工夫距离, HashedWheelTimer对其正则化 // 将其换算为大于等于该值的2^n wheel = createWheel(ticksPerWheel); // 这用来疾速计算工作应该呆的槽 mask = wheel.length - 1; // 工夫轮每个槽的工夫距离 this.tickDuration = unit.toNanos(tickDuration); // threadFactory是创立线程的线程工厂对象 workerThread = threadFactory.newThread(worker); // 最多容许多少个工作期待执行 this.maxPendingTimeouts = maxPendingTimeouts;} private static HashedWheelBucket[] createWheel(int ticksPerWheel) { // 计算真正该当创立多少个槽 ticksPerWheel = normalizeTicksPerWheel(ticksPerWheel); // 初始化工夫轮数组 HashedWheelBucket[] wheel = new HashedWheelBucket[ticksPerWheel]; for (int i = 0; i < wheel.length; i++) { wheel[i] = new HashedWheelBucket(); } return wheel;}初始化工夫轮之后，就能够向其中提交定时工作了，能够通过工夫轮提供的newTimeout办法来实现。首先将待处理的工作数量加1，而后启动工夫轮线程，这时worker的run办法就会被系统调度运行。而后将该定时工作封装成HashedWheelTimeout退出到timeouts队列中。start之后，工夫轮就开始运行起来了，直到外界调用stop办法终止退出。
public Timeout newTimeout(TimerTask task, long delay, TimeUnit unit) { // 待处理的工作数量加1 long pendingTimeoutsCount = pendingTimeouts.incrementAndGet(); // 启动工夫轮 start(); // 计算该定时工作的deadline long deadline = System.nanoTime() + unit.toNanos(delay) - startTime; // 创立一个HashedWheelTimeout对象，它首先会被暂存到timeouts队列中 HashedWheelTimeout timeout = new HashedWheelTimeout(this, task, deadline); timeouts.add(timeout); return timeout;}public void start() { /** * 判断以后工夫轮的状态 * 1) 如果是初始化, 则启动worker线程, 启动整个工夫轮 * 2) 如果曾经启动则略过 * 3) 如果是曾经进行,则报错 */ switch (WORKER_STATE_UPDATER.get(this)) { case WORKER_STATE_INIT: // 应用cas来判断启动工夫轮 if (WORKER_STATE_UPDATER.compareAndSet(this, WORKER_STATE_INIT, WORKER_STATE_STARTED)) { workerThread.start(); } break; case WORKER_STATE_STARTED: break; case WORKER_STATE_SHUTDOWN: // 抛异样 default: throw new Error("Invalid WorkerState"); } // 期待worker线程初始化工夫轮的启动工夫 while (startTime == 0) { try { // 这里应用countDownLatch来确保调度的线程曾经被启动 startTimeInitialized.await(); } catch (InterruptedException ignore) { // Ignore - it will be ready very soon. } }}三、工夫轮利用
到这里，Dubbo中的工夫轮原理就剖析完了。接下来响应本文结尾的三个例子，联合它们来剖析下工夫轮在Dubbo或Redisson中是如何应用的。
1）HeartbeatTimerTask
在Dubbo的HeaderExchangeClient类中会向工夫轮中提交该心跳工作。
private void startHeartBeatTask(URL url) { // Client的具体实现决定是否启动该心跳工作 if (!client.canHandleIdle()) { AbstractTimerTask.ChannelProvider cp = () -> Collections.singletonList(HeaderExchangeClient.this); // 计算心跳距离, 最小距离不能低于1s int heartbeat = getHeartbeat(url); long heartbeatTick = calculateLeastDuration(heartbeat); // 创立心跳工作 this.heartBeatTimerTask = new HeartbeatTimerTask(cp, heartbeatTick, heartbeat); // 提交到IDLE_CHECK_TIMER这个工夫轮中期待执行, 等工夫到了工夫轮就会去取出该工作进行调度执行 IDLE_CHECK_TIMER.newTimeout(heartBeatTimerTask, heartbeatTick, TimeUnit.MILLISECONDS); }}// 下面用到的IDLE_CHECK_TIMER就是咱们本文的剖析的工夫轮private static final HashedWheelTimer IDLE_CHECK_TIMER = new HashedWheelTimer(new NamedThreadFactory("dubbo-client-idleCheck", true), 1, TimeUnit.SECONDS, TICKS_PER_WHEEL);// 上述创立心跳工作时, 创立了一个HeartbeatTimerTask对象, 能够看下该工作具体要做什么@Overrideprotected void doTask(Channel channel) { try { // 获取最初一次读写工夫 Long lastRead = lastRead(channel); Long lastWrite = lastWrite(channel); if ((lastRead != null && now() - lastRead > heartbeat) || (lastWrite != null && now() - lastWrite > heartbeat)) { // 最初一次读写工夫超过心跳工夫, 就会发送心跳申请 Request req = new Request(); req.setVersion(Version.getProtocolVersion()); req.setTwoWay(true); // 表明它是一个心跳申请 req.setEvent(HEARTBEAT_EVENT); channel.send(req); } } catch (Throwable t) { }}2）Redisson锁续期机制
当获取锁胜利后，Redisson会封装一个锁续期工作放入工夫轮中，默认10s检查一下，用于对获取到的锁进行续期，缩短持有锁的工夫。如果业务机器宕机了，那么该续期的定时工作也就没法跑了，就没法续期了，那等加锁工夫到了锁就主动开释了。逻辑封装在RedissonLock中的renewExpiration()办法中。
private void renewExpiration() { ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName()); if (ee == null) { return; } // 这边newTimeout点进去发现就是往工夫轮中提交了一个工作 Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() { @Override public void run(Timeout timeout) throws Exception { ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName()); if (ent == null) { return; } Long threadId = ent.getFirstThreadId(); if (threadId == null) { return; } RFuture<Boolean> future = renewExpirationAsync(threadId); future.onComplete((res, e) -> { if (e != null) { log.error("Can't update lock " + getName() + " expiration", e); return; } if (res) { // 续期胜利后持续调度, 又往工夫轮中放一个续期工作 renewExpiration(); } }); } }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS); ee.setTimeout(task);}protected RFuture<Boolean> renewExpirationAsync(long threadId) { // 通过lua脚本对锁进行续期 return evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN, "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " + "redis.call('pexpire', KEYS[1], ARGV[1]); " + "return 1; " + "end; " + "return 0;", Collections.singletonList(getName()), internalLockLeaseTime, getLockName(threadId));}3）超时重试
应用形式和HeartbeatTimerTask形式相似，读者能够本人入手去剖析下它是在哪里被引入的。
四、总结
在本篇文章中，先是举了3个例子来阐述为什么须要应用工夫轮，应用工夫轮的长处，在文末处也别离对这3个例子在Dubbo或Redisson中的应用做了介绍。接着通过画图解说了单层工夫轮与多层工夫轮机制，让读者对工夫轮算法有了一个简略的意识。在第二局部，顺次解说了Dubbo工夫轮中波及到的TimerTask、Timeout、HashedWheelBucket、Worker、HashedWheelTimer，剖析了它们的原理与源码实现。
作者：vivo互联网服务器团队-Li Wanghong