Netty 时间轮算法实现HashedWheelTimer

1.HashedWheelTimer 参数解析

public HashedWheelTimer(
        ThreadFactory threadFactory,
        long tickDuration, TimeUnit unit, int ticksPerWheel, boolean leakDetection,
        long maxPendingTimeouts) {

1.ThreadFactory 自定义线程工厂，用于创建线程对象。

2.tickDuration  间隔多久走到下一槽（相当于时钟走一格）

3.unit 定义tickDuration的时间单位

4.ticksPerWheel 一圈有多个槽

5.leakDetection 是否开启内存泄漏检测。

6. maxPendingTimeouts 最多待执行的任务个数。0或负数表示无限制。

1.创建的槽位个数必须是2的次方，比如我传入的ticksPerWheel 是60，最后实际是64。

// Normalize ticksPerWheel to power of two and initialize the wheel.
wheel = createWheel(ticksPerWheel);

private static HashedWheelBucket[] createWheel(int ticksPerWheel) {
    if (ticksPerWheel <= 0) {
        throw new IllegalArgumentException(
                "ticksPerWheel must be greater than 0: " + ticksPerWheel);
    }
    if (ticksPerWheel > 1073741824) {
        throw new IllegalArgumentException(
                "ticksPerWheel may not be greater than 2^30: " + ticksPerWheel);
    }

    ticksPerWheel = normalizeTicksPerWheel(ticksPerWheel);
    HashedWheelBucket[] wheel = new HashedWheelBucket[ticksPerWheel];
    for (int i = 0; i < wheel.length; i ++) {
        wheel[i] = new HashedWheelBucket();
    }
    return wheel;
}

private static int normalizeTicksPerWheel(int ticksPerWheel) {
    int normalizedTicksPerWheel = 1;
    while (normalizedTicksPerWheel < ticksPerWheel) {
        normalizedTicksPerWheel <<= 1;
    }
    return normalizedTicksPerWheel;
}

2.tickDuration 转化为纳秒

// Convert tickDuration to nanos.
this.tickDuration = unit.toNanos(tickDuration);

转一圈的值不能大于Long.MAX_VALUE

// Prevent overflow.
if (this.tickDuration >= Long.MAX_VALUE / wheel.length) {
    throw new IllegalArgumentException(String.format(
            "tickDuration: %d (expected: 0 < tickDuration in nanos < %d",
            tickDuration, Long.MAX_VALUE / wheel.length));
}

3.HashedWheelTimer的实例不能超过64

private static final int INSTANCE_COUNT_LIMIT = 64;

if (INSTANCE_COUNTER.incrementAndGet() > INSTANCE_COUNT_LIMIT &&
    WARNED_TOO_MANY_INSTANCES.compareAndSet(false, true)) {
    reportTooManyInstances();
}

4.添加新任务maxPendingTimeouts 的检查限制

public Timeout newTimeout(TimerTask task, long delay, TimeUnit unit)

中有如下代码

if (maxPendingTimeouts > 0 && pendingTimeoutsCount > maxPendingTimeouts) {
    pendingTimeouts.decrementAndGet();
    throw new RejectedExecutionException("Number of pending timeouts ("
        + pendingTimeoutsCount + ") is greater than or equal to maximum allowed pending "
        + "timeouts (" + maxPendingTimeouts + ")");
}

long deadline = System.nanoTime() + unit.toNanos(delay) - startTime;
HashedWheelTimeout timeout = new HashedWheelTimeout(this, task, deadline);
timeouts.add(timeout);
return timeout;

private final Queue<HashedWheelTimeout> timeouts = PlatformDependent.newMpscQueue();

最后封装成HashedWheelTimout添加到队列（timeouts）中

2.工作线程

workerThread = threadFactory.newThread(worker);

private final Worker worker = new Worker();

我们看Worker关键代码

do {
    final long deadline = waitForNextTick();
    if (deadline > 0) {
        int idx = (int) (tick & mask);
        processCancelledTasks();
        HashedWheelBucket bucket =
                wheel[idx];
        transferTimeoutsToBuckets();
        bucket.expireTimeouts(deadline);
        tick++;
    }
} while (WORKER_STATE_UPDATER.get(HashedWheelTimer.this) == WORKER_STATE_STARTED);

我们看下面这个方法，它将队列（newTask的时候添加任务的那个队列）中的任务放到对应的HashedWheelBucket中。

private void transferTimeoutsToBuckets() {
    // transfer only max. 100000 timeouts per tick to prevent a thread to stale the workerThread when it just
    // adds new timeouts in a loop.
    for (int i = 0; i < 100000; i++) {
        HashedWheelTimeout timeout = timeouts.poll();
        if (timeout == null) {
            // all processed
            break;
        }
        if (timeout.state() == HashedWheelTimeout.ST_CANCELLED) {
            // Was cancelled in the meantime.
            continue;
        }

        long calculated = timeout.deadline / tickDuration;
        timeout.remainingRounds = (calculated - tick) / wheel.length;

        final long ticks = Math.max(calculated, tick); // Ensure we don't schedule for past.
        int stopIndex = (int) (ticks & mask);

        HashedWheelBucket bucket = wheel[stopIndex];
        bucket.addTimeout(timeout);
    }
}

计算需要轮询多少轮（remainingRounds） ，以及哪个槽（stopIndex） ，放入对应的HashedWheelBucked中。

执行当前槽的到期任务

public void expireTimeouts(long deadline) {
    HashedWheelTimeout timeout = head;

    // process all timeouts
    while (timeout != null) {
        HashedWheelTimeout next = timeout.next;
        if (timeout.remainingRounds <= 0) {
            next = remove(timeout);
            if (timeout.deadline <= deadline) {
                timeout.expire();
            } else {
                // The timeout was placed into a wrong slot. This should never happen.
                throw new IllegalStateException(String.format(
                        "timeout.deadline (%d) > deadline (%d)", timeout.deadline, deadline));
            }
        } else if (timeout.isCancelled()) {
            next = remove(timeout);
        } else {
            timeout.remainingRounds --;
        }
        timeout = next;
    }
}

如果是到期了，则执行任务，否则将remainingRounds 减一。

执行任务的方法：

public void expire() {
    if (!compareAndSetState(ST_INIT, ST_EXPIRED)) {
        return;
    }

    try {
        task.run(this);
    } catch (Throwable t) {
        if (logger.isWarnEnabled()) {
            logger.warn("An exception was thrown by " + TimerTask.class.getSimpleName() + '.', t);
        }
    }
}

3.总结

  当添加新的延迟任务时（newTimeOut），将任务封装成HashedWheelTimeout对象，然后添加到timeouts队列中，工作线程（Worker）每间隔tickDuration时间向前走一格，找到当前槽位中对应的对象（HashedWheelBucket链表），然后将timeouts队列中的前100000个任务放入对应的槽位中，最后遍历当前槽位中任务看是否过期可以执行了。

HashedWheelTimer hashedWheelTimer = new HashedWheelTimer(new ThreadFactory() {
    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r, "HashedWheelTimerTest");
    }
}, 1, TimeUnit.SECONDS, 60, true, 10);
hashedWheelTimer.start();

final long millis = System.currentTimeMillis();

hashedWheelTimer.newTimeout(new TimerTask() {
    @Override
    public void run(Timeout timeout) throws Exception {
        System.out.println("done:" + (System.currentTimeMillis() - millis));
        System.out.println(timeout);
    }
}, 1, TimeUnit.SECONDS);