Netty中的时间轮

<dependency>
    <groupId>org.jboss.netty</groupId>
    <artifactId>netty</artifactId>
    <version>3.2.5.Final</version>
</dependency>

// 构造器
public HashedWheelTimer(
            ThreadFactory threadFactory,
            long tickDuration, TimeUnit unit, int ticksPerWheel) {

  wheel = createWheel(ticksPerWheel);// 创建时间轮,实际就是一个Set数组
  iterators = createIterators(wheel);// 创建每个Set元素的迭代器
  mask = wheel.length - 1;

  this.tickDuration = tickDuration = unit.toMillis(tickDuration);// 每个格子的时间跨度

  roundDuration = tickDuration * wheel.length; // 转一圈的时间

  // 执行时间轮里面任务的线程
  workerThread = threadFactory.newThread(new ThreadRenamingRunnable(worker, "Hashed wheel timer #" + id.incrementAndGet()));

}

// 源码位置: org.jboss.netty.util.HashedWheelTimer.Worker#run
public void run() {
  List<HashedWheelTimeout> expiredTimeouts = new ArrayList<HashedWheelTimeout>();
  // 记录时间轮启动的开始时间
  startTime = System.currentTimeMillis();
  // 从tick=1的位置开始执行
  tick = 1;
  
  while (!shutdown.get()) {
    // 等到下一个tick的时间到达
    final long deadline = waitForNextTick();
    if (deadline > 0) {
      // 获取到期的任务
      fetchExpiredTimeouts(expiredTimeouts, deadline);
      // 执行到期的任务
      notifyExpiredTimeouts(expiredTimeouts);
    }
  }
}

private long waitForNextTick() {
  // 计算第tick格子的结束时刻
  long deadline = startTime + tickDuration * tick;

  for (;;) {
    final long currentTime = System.currentTimeMillis();
    // 可以等价于startTime + tickDuration * tick - currentTime
    final long sleepTime = tickDuration * tick - (currentTime - startTime);
    // 根据上面的等式,它的意思就是说必须等到时间走到了当前格子的结束时刻才终止.
    if (sleepTime <= 0) {
      break;
    }

    try {
        // 如果时间还没有走到tick格子的结束时刻则sleep
      Thread.sleep(sleepTime);
    } catch (InterruptedException e) {
      if (shutdown.get()) {
        return -1;
      }
    }
  }
    // tick加1
  tick ++;
  return deadline;
}

// 这个方法都在处理同一个格子里面的任务
private void fetchExpiredTimeouts(
                List<HashedWheelTimeout> expiredTimeouts,
                ReusableIterator<HashedWheelTimeout> i, long deadline) {

  List<HashedWheelTimeout> slipped = null;
  i.rewind();
  // 每个格子的底层都是通过HashMap存储任务的,而且每个格子都有一个迭代器,用于迭代HashMap中的任务.
  while (i.hasNext()) {
    HashedWheelTimeout timeout = i.next();
    // 有些任务是在这一圈就要执行,有些任务是要等到第2圈,第3圈...才会执行的.这里只会找出这一圈需要执行的任务
    if (timeout.remainingRounds <= 0) {
      i.remove();
      // 如果任务已经过期,则加入集合中,接下来就会执行这个任务
      if (timeout.deadline <= deadline) {
        expiredTimeouts.add(timeout);
      } else {
        if (slipped == null) {
          slipped = new ArrayList<HashedWheelTimer.HashedWheelTimeout>();
        }
        // 有些任务可能放错了格子,需要重新放入格子
        slipped.add(timeout);
      }
    } else {
      timeout.remainingRounds --;
    }
  }

  if (slipped != null) {
    for (HashedWheelTimeout timeout: slipped) {
      scheduleTimeout(timeout, timeout.deadline - deadline);
    }
  }
}

private void notifyExpiredTimeouts(List<HashedWheelTimeout> expiredTimeouts) {
  // 遍历列表,执行任务
  for (int i = expiredTimeouts.size() - 1; i >= 0; i --) {
    expiredTimeouts.get(i).expire();
  }

  expiredTimeouts.clear();
}