在前面的文章《时间轮-理论篇》讲了时间轮的一些理论知识，然后根据理论知识。我们自己来实现一个简单的时间轮。
1. 理论抽象
将时间轮的理论进行抽象，主要有两个方面：
- 时间轮的转动
- 每一个时间间隔任务的处理，从时间间隔的Buket中取出要执行的任务，删除已经关闭的任务。将任务提交给线程池进行执行处理
2.Java实现
接口：
public interface Timer {
void createTimerTask(TimerTask task, long delay, TimeUnit unit);
}
public interface TimerTask {
void run();
}实现类：
public class TimeWheel implements Timer {
private ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
private BlockingQueue<TimerTaskWrapper> addQueue = new ArrayBlockingQueue<>(128);
//每一个tick时间间隔默认1毫秒
private final long duration;
//时间轮启动时间
private volatile long startTime;
private Thread timeWheelThread;
private CountDownLatch startLatch = new CountDownLatch(1);
//时间轮的tick数量
private int tickNum = 128;
private Bucket[] buckets;
private boolean started = false;
public TimeWheel(long duration, TimeUnit unit) {
long nanos = unit.toNanos(duration);
if (TimeUnit.MILLISECONDS.toNanos(1) > nanos) {
this.duration = 1;
} else {
this.duration = unit.toMillis(duration);
}
this.timeWheelThread = new Thread(new Worker());
this.buckets = new Bucket[tickNum];
for (int i = 0; i < tickNum; ++i) {
this.buckets[i] = new Bucket();
}
}
@Override
public void createTimerTask(TimerTask task, long delay, TimeUnit unit) {
start();
long deadline = System.currentTimeMillis() + unit.toMillis(delay) - startTime;
System.out.println("deadline="+deadline);
addQueue.offer(new TimerTaskWrapper(task, deadline));
}
private void start() {
if (started) {
return;
}
started = true;
timeWheelThread.start();
try {
startLatch.await();
System.out.println("启动完成");
} catch (Exception e) {
e.printStackTrace();
}
}
//处理时间轮的转动
class Worker implements Runnable {
//记录tick的次数
private long tick;
@Override
public void run() {
startTime = System.currentTimeMillis();
startLatch.countDown();
System.out.println("Worker 启动完成..........");
for (; ; ) {
long time = nextTick();
if (time <= 0) {
continue;
}
int bucketIndex = (int) (tick & (tickNum - 1));
System.out.println("bucketIndex="+bucketIndex);
Bucket bucket = buckets[bucketIndex];
//处理阻塞队列中的task
doHandleQueneTask();
//处理过期数据
bucket.expire(time);
tick++;
}
}
private void doHandleQueneTask() {
for (int i = 0; i < 1024; ++i) {
TimerTaskWrapper taskWrapper = addQueue.poll();
//队列为空
if (taskWrapper == null) {
break;
}
long taskTicks = taskWrapper.deadline / duration;
taskWrapper.rounds = (taskTicks - tick) / tickNum;
final long ticks = Math.max(taskTicks, tick);
int bucketIndex = (int) (ticks & (tickNum - 1));
System.out.println("inster bucketIndex = " + bucketIndex);
Bucket bucket = buckets[bucketIndex];
bucket.addTimerTask(taskWrapper);
}
}
private long nextTick() {
long deadline = duration * (tick + 1);
for (; ; ) {
long current = System.currentTimeMillis() - startTime;
long sleepTime = deadline - current;
if (sleepTime <= 0) {
return current;
}
try {
Thread.sleep(sleepTime);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
class TimerTaskWrapper implements Runnable {
private TimerTask task;
//任务执行截止时间
protected long deadline;
//多少圈
protected long rounds;
TimerTaskWrapper prev;
TimerTaskWrapper next;
public TimerTaskWrapper(TimerTask task, long deadline) {
this.task = task;
this.deadline = deadline;
}
@Override
public void run() {
task.run();
}
public void expire() {
service.execute(this);
}
}
class Bucket {
TimerTaskWrapper head;
TimerTaskWrapper tail;
public void addTimerTask(TimerTaskWrapper task) {
if (task == null) {
return;
}
if (head == null) {
tail = task;
head = tail;
} else {
tail.next = task;
task.prev = tail;
tail = task;
}
}
public TimerTaskWrapper removeTimerTask(TimerTaskWrapper task) {
TimerTaskWrapper next = task.next;
if (task.prev != null) {
task.prev.next = next;
}
if (task.next != null) {
task.next.prev = task.prev;
}
if (task == head) {
if (task == tail) {
head = null;
tail = null;
} else {
head = next;
}
} else if (task == tail) {
tail = task.prev;
}
task.prev = null;
task.next = null;
return next;
}
public void expire(long deadline) {
TimerTaskWrapper task = head;
while (task != null) {
TimerTaskWrapper next = task.next;
if (task.rounds <= 0) {
next = removeTimerTask(task);
if (task.deadline <= deadline) {
task.expire();
}
} else {
//减少时间轮的圈数
task.rounds--;
}
task = next;
}
}
}
}编写一个测试案例来测试一下：
public class Test {
public static void main(String[] args) {
final TimeWheel wheel = new TimeWheel(1, TimeUnit.SECONDS);
wheel.createTimerTask(new TimerTask() {
@Override
public void run() {
System.out.println(1111);
wheel.createTimerTask(this, 4, TimeUnit.SECONDS);
}
}, 3,TimeUnit.SECONDS);
}
}运行打印结果：
说明：从日志的打印可以发现，在延迟三秒的情况下你会发现打印了 bucketIndex=xxx 四次。为什么会这样打印四次呢？因为当时间轮的tick在当前的时间间隔内，这个时间是不算的，从下个开始的。所以打印了四次。
3. 总结
从上面的实现可以看出来，时间间隔越长调用的就越不准确。例如刚开始的时候添加了任务到时间轮中，那么当前时间间隔就需要多消耗，实际的添加任务的执行时间为：当前时间轮剩下的时间+任务延迟执行的时间。所以如果对任务执行需要精确时间时间轮不适合。
我是蚂蚁背大象，文章对你有帮助点赞关注我，文章有不正确的地方请您斧正留言评论~谢谢！
