private void addFailedRegistered(URL url) {
  FailedRegisteredTask oldOne = failedRegistered.get(url);
  if (oldOne != null) {
    return;
  }
  FailedRegisteredTask newTask = new FailedRegisteredTask(url, this);
  oldOne = failedRegistered.putIfAbsent(url, newTask);
  if (oldOne == null) {
    // never has a retry task. then start a new task for retry.
    retryTimer.newTimeout(newTask, retryPeriod, TimeUnit.MILLISECONDS);
  }
}

private void addFailed(LoadBalance loadbalance, Invocation invocation,
List<Invoker<T>> invokers, Invoker<T> lastInvoker) {
  if (failTimer == null) {
    synchronized (this) {
      if (failTimer == null) {
        failTimer = new HashedWheelTimer(
          new NamedThreadFactory("failback-cluster-timer", true),1,TimeUnit.SECONDS, 32, failbackTasks);
        }
      }
    }
    RetryTimerTask retryTimerTask = new RetryTimerTask(loadbalance,
invocation, invokers, lastInvoker, retries, RETRY_FAILED_PERIOD);
    try {
      failTimer.newTimeout(retryTimerTask, RETRY_FAILED_PERIOD,TimeUnit.SECONDS);
    } catch (Throwable e) {
      logger.error("Failback background works error,invocation->" +invocation + ", exception: " + e.getMessage());
    }
  }

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);
  }
  //对传入的时间轮大小进行整形，整形成2的幂次方
  ticksPerWheel = normalizeTicksPerWheel(ticksPerWheel);
  //初始化一个固定长度的Bucket数组
  HashedWheelBucket[] wheel = new HashedWheelBucket[ticksPerWheel];
  for (int i = 0; i < wheel.length; i++) {
    wheel[i] = new HashedWheelBucket();
  }
  return wheel;
}

RetryTimerTask retryTimerTask = new RetryTimerTask(loadbalance, invocation,
invokers, lastInvoker, retries, RETRY_FAILED_PERIOD);
failTimer.newTimeout(retryTimerTask, RETRY_FAILED_PERIOD, TimeUnit.SECONDS);

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();
  //判断最大任务数量是否超过限制
  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方法进行启动
  start();
  //计算任务的延迟时间，通过当前的时间+当前任务执行的延迟时间-时间轮启动的时间。
  long deadline = System.nanoTime() + unit.toNanos(delay) - startTime;
    //在delay为正数的情况下，deadline是不可能为负数
    //如果为负数，那么说明超过了long的最大值
    if (delay > 0 && deadline < 0) {
      deadline = Long.MAX_VALUE;
    }
  //创建一个Timeout任务，理论上来说，这个任务应该要加入到时间轮的时间格子中，但是这里并不是先添加到时间格，而是先加入到一个阻塞队列，然后等到时间轮执行到下一个格子时，再从队列中取出最多100000个任务添加到指定的时间格（槽）中。
    HashedWheelTimeout timeout = new HashedWheelTimeout(this, task, deadline);
    timeouts.add(timeout);// 生产者消费者模型
    return timeout;
}

public void run() {
  // 初始化startTime，表示时间轮的启动时间
  startTime = System.nanoTime();
  if (startTime == 0) {
    startTime = 1;
  }
  // 唤醒被阻塞的start()方法。
  startTimeInitialized.countDown();
  do {
    //返回每tick一次的时间间隔
    final long deadline = waitForNextTick();
    if (deadline > 0) {
      //计算时间轮的槽位
      int idx = (int) (tick & mask);
            //移除掉CancelledTask
            processCancelledTasks();
            //得到当前指针位置的时间槽
            HashedWheelBucket bucket =wheel[idx];
            //将newTimeout()方法中加入到待处理定时任务队列中的任务加入到指定的格子中
            transferTimeoutsToBuckets();
            //运行目前指针指向的槽中的bucket链表中的任务
            bucket.expireTimeouts(deadline);
      tick++;
    }
  } while (WORKER_STATE_UPDATER.get(HashedWheelTimer.this) ==
WORKER_STATE_STARTED);
  //如果Worker_State一只是started状态，就一直循环
  for (HashedWheelBucket bucket : wheel) {
    bucket.clearTimeouts(unprocessedTimeouts); //清除时间轮中不需要处理的任务
  }
  for (; ; ) {
    //遍历任务队列，发现如果有任务被取消，则添加到unprocessedTimeouts,也就是不需要处理的队列中。
    HashedWheelTimeout timeout = timeouts.poll();
        if (timeout == null) {
          break;
        }
        if (!timeout.isCancelled()) {
          unprocessedTimeouts.add(timeout);
        }
  }
    //处理被取消的任务.
    processCancelledTasks();
}

// waitForNextTick 方法也就理解到位了，它干的事儿就是等，等一个时间刻度的时间，等一个 tick 长度的时间。
private long waitForNextTick() {
    //tick表示总的tick数
    //tickDuration表示每个时间格的跨度，所以deadline返回的是下一次时间轮指针跳动的时间
  long deadline = tickDuration * (tick + 1);
  for (; ; ) {
    //计算当前时间距离启动时间的时间间隔
    final long currentTime = System.nanoTime() - startTime;
        //通过下一次指针跳动的延迟时间距离当前时间的差额，这个作为sleep时间使用。
        // 其实线程是以睡眠一定的时候再来执行下一个ticket的任务的
        long sleepTimeMs = (deadline - currentTime + 999999) / 1000000;
        //sleepTimeMs小于零表示走到了下一个时间槽位置
    if (sleepTimeMs <= 0) {
      if (currentTime == Long.MIN_VALUE) {
        return -Long.MAX_VALUE;
      } else {
        return currentTime;
      }
    }
    if (isWindows()) {
      sleepTimeMs = sleepTimeMs / 10 * 10;
    }
    //进入到这里进行sleep，表示当前时间距离下一次tick时间还有一段距离，需要sleep。
    try {
      Thread.sleep(sleepTimeMs);
    } catch (InterruptedException ignored) {
      if (WORKER_STATE_UPDATER.get(HashedWheelTimer.this) ==
WORKER_STATE_SHUTDOWN) {
        return Long.MIN_VALUE;
      }
    }
  }
}

void expireTimeouts(long deadline) {
  HashedWheelTimeout timeout = head;
  // 遍历当前时间槽中的所有任务
  while (timeout != null) {
    HashedWheelTimeout next = timeout.next;
    //如果当前任务要被执行，那么remainingRounds应该小于或者等于0
    if (timeout.remainingRounds <= 0) {
      //从bucket链表中移除当前timeout，并返回链表中下一个timeout
      next = remove(timeout);
      //如果timeout的时间小于当前的时间，那么就调用expire执行task
      if (timeout.deadline <= deadline) {
        timeout.expire();
      } else {
        //不可能发生的情况，就是说round已经为0了，deadline却>当前槽的deadline
        throw new IllegalStateException(String.format("timeout.deadline (%d) > deadline (%d)", timeout.deadline,deadline));
      }
    } else if (timeout.isCancelled()) {
      next = remove(timeout);
    } else {
      //因为当前的槽位已经过了，说明已经走了一圈了，把轮数减一
      timeout.remainingRounds--;
    }
    //把指针放置到下一个timeout
    timeout = next;
  }
}

public static void received(Channel channel, Response response, boolean timeout) {
        try {
            DefaultFuture future = (DefaultFuture)FUTURES.remove(response.getId());
            if (future != null) {
                Timeout t = future.timeoutCheckTask;
                if (!timeout) {
                    t.cancel();
                }
                future.doReceived(response);
            } else {
                logger.warn("The timeout response finally returned at " + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS")).format(new Date()) + ", response status is " + response.getStatus() + (channel == null ? "" : ", channel: " + channel.getLocalAddress() + " -> " + channel.getRemoteAddress()) + ", please check provider side for detailed result.");
            }
        } finally {
            CHANNELS.remove(response.getId());
        }
    }