/**
 *  tickDuration：一格的时长
 *  ticksPerWheel：一圈有几格
 */
public HashedWheelTimer(
        ThreadFactory threadFactory,
        long tickDuration, TimeUnit unit, int ticksPerWheel,
        long maxPendingTimeouts) {
    //参数校验
    if (threadFactory == null) {
        throw new NullPointerException("threadFactory");
    }
    if (unit == null) {
        throw new NullPointerException("unit");
    }
    if (tickDuration <= 0) {
        throw new IllegalArgumentException("tickDuration must be greater than 0: " + tickDuration);
    }
    if (ticksPerWheel <= 0) {
        throw new IllegalArgumentException("ticksPerWheel must be greater than 0: " + ticksPerWheel);
    }

    //创建时间轮(其实就是构建数组并初始化),长度为不小于ticksPerWheel的最小2的n次方
    // Normalize ticksPerWheel to power of two and initialize the wheel.
    wheel = createWheel(ticksPerWheel);
    mask = wheel.length - 1;

    // 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));
    }
    //创建worker线程
    workerThread = threadFactory.newThread(worker);

    this.maxPendingTimeouts = maxPendingTimeouts;

    //控制时间轮产生的实例个数，如果产生的实例过多，打个error日志
    if (INSTANCE_COUNTER.incrementAndGet() > INSTANCE_COUNT_LIMIT &&
            WARNED_TOO_MANY_INSTANCES.compareAndSet(false, true)) {
        reportTooManyInstances();
    }
}

@Override
public Timeout newTimeout(TimerTask task, long delay, TimeUnit unit) {
    //入参非空校验
    if (task == null) {
        throw new NullPointerException("task");
    }
    if (unit == null) {
        throw new NullPointerException("unit");
    }

    //校验最大可以接受的任务数量
    long pendingTimeoutsCount = pendingTimeouts.incrementAndGet();
    //如果maxPendingTimeouts<=0,则不限制接受任务的数量
    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 + ")");
    }

    //启动时间轮(如果已启动则略过)
    start();

    // Add the timeout to the timeout queue which will be processed on the next tick.
    // During processing all the queued HashedWheelTimeouts will be added to the correct HashedWheelBucket.
    //计算任务的deadline
    long deadline = System.nanoTime() + unit.toNanos(delay) - startTime;

    // Guard against overflow.
    if (delay > 0 && deadline < 0) {
        deadline = Long.MAX_VALUE;
    }
    //将定时任务添加到任务队列中，HashedWheelTimeout是一个链表结构
    //添加到队列中的HashedWheelTimeout会被定时器的HashedWheelBucket存放
    HashedWheelTimeout timeout = new HashedWheelTimeout(this, task, deadline);
    timeouts.add(timeout);
    return timeout;
}

@Override
public void run() {
    // Initialize the startTime.
    startTime = System.nanoTime();
    if (startTime == 0) {
        // We use 0 as an indicator for the uninitialized value here, so make sure it's not 0 when initialized.
        startTime = 1;
    }

    //唤醒阻塞的在start()方法的线程
    // Notify the other threads waiting for the initialization at start().
    startTimeInitialized.countDown();

    //循环执行，除非时间轮状态不是WORKER_STATE_STARTED了(stop了)
    do {
        //sleep到下一个tick
        final long deadline = waitForNextTick();
        if (deadline > 0) {
            //获取tick对应格子的索引
            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);

    //时间轮被stop了，将没有处理完的任务添加到unprocessedTimeouts中，方便调用stop方法时获取
    // Fill the unprocessedTimeouts so we can return them from stop() method.
    for (HashedWheelBucket bucket : wheel) {
        bucket.clearTimeouts(unprocessedTimeouts);
    }
    //将处理定时任务队列中的任务取出，加入到unprocessedTimeouts队列中，方便调用stop方法时获取
    for (; ; ) {
        HashedWheelTimeout timeout = timeouts.poll();
        if (timeout == null) {
            break;
        }
        if (!timeout.isCancelled()) {
            unprocessedTimeouts.add(timeout);
        }
    }
    processCancelledTasks();
}