public interface Timer {

    /**
     * 啟動時間輪
     * */
    void startTimeWheel();

    /**
     * 創(chuàng)建新的超時任務(wù)(必須先startTimeWheel完成后，才能創(chuàng)建新任務(wù))
     * @param task 超時時需要調(diào)度的自定義任務(wù)
     * @param delayTime 延遲時間
     * @param timeUnit 延遲時間delayTime的單位
     * */
    void newTimeoutTask(Runnable task, long delayTime, TimeUnit timeUnit);
}

/**
 * 參考netty實現(xiàn)的單層時間輪
 * */
public class MyHashedTimeWheel implements Timer{

    /**
     * 環(huán)形數(shù)組
     * */
    private final MyHashedTimeWheelBucket[] ringBucketArray;

    /**
     * 世間輪啟動時的具體時間戳(單位：納秒nanos)
     * */
    private long startTime;

    /**
     * 是否已啟動
     * */
    private final AtomicBoolean started = new AtomicBoolean(false);

    /**
     * 時間輪每次轉(zhuǎn)動的時間(單位：納秒nanos)
     * (perTickTime越短，調(diào)度會更精確，但cpu開銷也會越大)
     * */
    private final long perTickTime;

    /**
     * 總tick數(shù)
     * */
    private long totalTick = 0;

    /**
     * 待處理任務(wù)的隊列
     * (多外部生產(chǎn)者寫入，時間輪內(nèi)的單worker消費者讀取，所以netty的實現(xiàn)里使用了效率更高的MpscQueue，Mpsc即MultiProducerSingleConsumer)
     * */
    private final Queue<MyTimeoutTaskNode> unProcessTaskQueue = new LinkedBlockingDeque<>();

    /**
     * 用于實際執(zhí)行到期任務(wù)的線程池
     * */
    private final Executor taskExecutor;

    private Thread workerThread;

    /**
     * 構(gòu)造函數(shù)
     * */
    public MyHashedTimeWheel(int ringArraySize, long perTickTime, Executor taskExecutor) {
        this.ringBucketArray = new MyHashedTimeWheelBucket[ringArraySize];
        for(int i=0; i<ringArraySize; i++){
            // 初始化，填充滿時間輪喚醒數(shù)組
            this.ringBucketArray[i] = new MyHashedTimeWheelBucket();
        }

        this.perTickTime = perTickTime;
        this.taskExecutor = taskExecutor;
    }

    /**
     * 啟動worker線程等初始化操作，必須執(zhí)行完成后才能正常工作
     * (簡單起見，和netty不一樣不是等任務(wù)被創(chuàng)建時才懶加載的，必須提前啟動)
     * */
    @Override
    public void startTimeWheel(){
        // 啟動worker線程
        this.workerThread = new Thread(new Worker());
        this.workerThread.start();

        while (!this.started.get()){
            // 自旋循環(huán)，等待一會
        }

        System.out.println("startTimeWheel 啟動完成:" + this.getClass().getSimpleName());
    }

    @Override
    public void newTimeoutTask(Runnable task, long delayTime, TimeUnit timeUnit){
        long deadline = System.nanoTime() + timeUnit.toNanos(delayTime);

        // Guard against overflow.
        if (delayTime > 0 && deadline < 0) {
            deadline = Long.MAX_VALUE;
        }

        MyTimeoutTaskNode newTimeoutTaskNode = new MyTimeoutTaskNode();
        newTimeoutTaskNode.setTargetTask(task);
        newTimeoutTaskNode.setDeadline(deadline);

        unProcessTaskQueue.add(newTimeoutTaskNode);
    }

    private final class Worker implements Runnable{

        @Override
        public void run() {
            MyHashedTimeWheel.this.startTime = System.nanoTime();

            // 啟動
            MyHashedTimeWheel.this.started.set(true);

            // 簡單起見，不考慮優(yōu)雅啟動和暫停的邏輯
            while (true){
                // 等待perTick
                waitForNextTick();

                // 在撈取當前tick下需要處理的bucket前，先將加入到隊列中的任務(wù)轉(zhuǎn)移到環(huán)形數(shù)組中(可能包含在當前tick下就要處理的任務(wù))
                transferTaskToBuckets();

                // 基于總tick數(shù)，對環(huán)形數(shù)組的長度取模，計算出當前tick下需要處理的bucket桶的下標
                int idx = (int) (MyHashedTimeWheel.this.totalTick % MyHashedTimeWheel.this.ringBucketArray.length);
                MyHashedTimeWheelBucket bucket = MyHashedTimeWheel.this.ringBucketArray[idx];
                // 處理當前插槽內(nèi)的任務(wù)(遍歷鏈表中的所有任務(wù)，round全部減一，如果減為負數(shù)了則說明這個任務(wù)超時到期了，將其從鏈表中移除后并交給線程池執(zhí)行指定的任務(wù))
                bucket.expireTimeoutTask(MyHashedTimeWheel.this.taskExecutor);
                // 循環(huán)tick一次，總tick數(shù)自增1
                MyHashedTimeWheel.this.totalTick++;
            }
        }

        /**
         * per tick時鐘跳動，基于Thread.sleep
         * */
        private void waitForNextTick(){
            // 由于Thread.sleep并不是絕對精確的被喚醒，所以只能通過(('總的tick數(shù)+1' * '每次tick的間隔') + '時間輪啟動時間')來計算精確的下一次tick時間
            // 而不能簡單的Thread.sleep(每次tick的間隔)

            long nextTickTime = (MyHashedTimeWheel.this.totalTick + 1) * MyHashedTimeWheel.this.perTickTime
                            + MyHashedTimeWheel.this.startTime;

            // 因為nextTickTime是納秒，sleep需要的是毫秒，需要保證納秒數(shù)過小時，導(dǎo)致直接計算出來的毫秒數(shù)為0
            // 因此(‘實際休眠的納秒數(shù)'+999999)/1000000,保證了納秒轉(zhuǎn)毫秒時，至少會是1毫秒，而不會出現(xiàn)sleep(0毫秒)令cpu空轉(zhuǎn)
            long needSleepTime = (nextTickTime - System.nanoTime() + 999999) / 1000000;
            try {
                // 比起netty，忽略了一些處理特殊場景bug的邏輯
                Thread.sleep(needSleepTime);
            } catch (InterruptedException ignored) {

            }
        }

        private void transferTaskToBuckets() {
            // 為了避免worker線程在一次循環(huán)中處理太多的任務(wù)，所以直接限制了一個最大值100000
            // 如果真的有這么多，就等到下次tick循環(huán)的時候再去做。
            // 因為這個操作是cpu密集型的，處理太多的話，可能導(dǎo)致無法在一個短的tick周期內(nèi)完成一次循環(huán)
            for (int i = 0; i < 100000; i++) {
                MyTimeoutTaskNode timeoutTaskNode = MyHashedTimeWheel.this.unProcessTaskQueue.poll();
                if (timeoutTaskNode == null) {
                    // 隊列為空了，直接結(jié)束
                    return;
                }

                // 計算到任務(wù)超時時，應(yīng)該執(zhí)行多少次tick
                // (和netty里的不一樣，這里的deadline是超時時間的絕對時間，所以需要先減去時間輪的startTime)
                // (netty中是生產(chǎn)者線程在add時事先減去了startTime，比起由worker線程統(tǒng)一處理效率更高，但個人覺得這里的寫法會更直觀)
                long totalTickWhenTimeout = (timeoutTaskNode.getDeadline() - MyHashedTimeWheel.this.startTime) / MyHashedTimeWheel.this.perTickTime;
                // 減去當前時間輪已經(jīng)進行過的tick數(shù)量
                long remainingTickWhenTimeout = (totalTickWhenTimeout - MyHashedTimeWheel.this.totalTick);
                // 因為一次時間輪旋轉(zhuǎn)會經(jīng)過ringBucketArray.length次tick，所以求個余數(shù)
                long remainingRounds = remainingTickWhenTimeout / MyHashedTimeWheel.this.ringBucketArray.length;
                // 計算出當前任務(wù)需要轉(zhuǎn)多少圈之后才會超時
                timeoutTaskNode.setRounds(remainingRounds);

                // 如果傳入的deadline早于當前系統(tǒng)時間，則totalTickWhenTimeout可能會小于當前的totalTick
                // 這種情況下，讓這個任務(wù)在當前tick下就立即超時而被調(diào)度是最合理的，而不能在求余后放到一個錯誤的位置而等一段時間才調(diào)度（所以必須取兩者的最大值）
                final long ticks = Math.max(totalTickWhenTimeout, MyHashedTimeWheel.this.totalTick); // Ensure we don't schedule for past.
                // 如果能限制環(huán)形數(shù)組的長度為2的冪，則可以改為ticks & mask，位運算效率更高
                int stopIndex = (int) (ticks % MyHashedTimeWheel.this.ringBucketArray.length);
                MyHashedTimeWheelBucket bucket = MyHashedTimeWheel.this.ringBucketArray[stopIndex];
                // 計算并找到應(yīng)該被放置的那個bucket后，將其插入當前bucket指向的鏈表中
                bucket.addTimeout(timeoutTaskNode);
            }
        }
    }
}

/**
 * 時間輪環(huán)形數(shù)組下標對應(yīng)的桶(保存一個超時任務(wù)MyTimeoutTaskNode的鏈表)
 * */
public class MyHashedTimeWheelBucket {

    private final LinkedList<MyTimeoutTaskNode> linkedList = new LinkedList<>();

    public void addTimeout(MyTimeoutTaskNode timeout) {
        linkedList.add(timeout);
    }

    /**
     * 遍歷鏈表中的所有任務(wù)，round全部減一，如果減為負數(shù)了則說明這個任務(wù)超時到期了，將其從鏈表中移除后并交給線程池執(zhí)行指定的任務(wù)
     * */
    public void expireTimeoutTask(Executor executor){
        Iterator<MyTimeoutTaskNode> iterator = linkedList.iterator();
        while(iterator.hasNext()){
            MyTimeoutTaskNode currentNode = iterator.next();
            long currentNodeRound = currentNode.getRounds();
            if(currentNodeRound <= 0){
                // 將其從鏈表中移除
                iterator.remove();
                // count小于等于0，說明超時了，交給線程池去異步執(zhí)行
                executor.execute(currentNode.getTargetTask());
            }else{
                // 當前節(jié)點還未超時，round自減1
                currentNode.setRounds(currentNodeRound-1);
            }

            // 簡單起見，不考慮任務(wù)被外部自己取消的case(netty里的timeout.isCancelled())
        }
    }
}

public class MyTimeoutTaskNode {

    /**
     * 任務(wù)具體的到期時間(絕對時間)
     * */
    private long deadline;

    /**
     * 存儲在時間輪中，需要等待的輪次
     * (rounds在初始化后，每次時間輪轉(zhuǎn)動一周便自減1，當減為0時便代表當前任務(wù)需要被調(diào)度)
     * */
    private long rounds;

    /**
     * 創(chuàng)建任務(wù)時，用戶指定的到期時進行調(diào)度的任務(wù)
     * */
    private Runnable targetTask;

    public long getDeadline() {
        return deadline;
    }

    public void setDeadline(long deadline) {
        this.deadline = deadline;
    }

    public long getRounds() {
        return rounds;
    }

    public void setRounds(long rounds) {
        this.rounds = rounds;
    }

    public Runnable getTargetTask() {
        return targetTask;
    }

    public void setTargetTask(Runnable targetTask) {
        this.targetTask = targetTask;
    }
}

/**
 * 層次時間輪，會存在空轉(zhuǎn)問題
 * */
public class MyHierarchicalHashedTimerV1 implements Timer {

    /**
     * 是否已啟動
     * */
    private AtomicBoolean started = new AtomicBoolean(false);

    /**
     * 世間輪啟動時的具體時間戳(單位：納秒nanos)
     * */
    private long startTime;

    /**
     * 時間輪每次轉(zhuǎn)動的時間(單位：納秒nanos)
     * (perTickTime越短，調(diào)度會更精確，但cpu開銷也會越大)
     * */
    private final long perTickTime;

    /**
     * 總tick數(shù)
     * */
    private long totalTick = 0;

    /**
     * 待處理任務(wù)的隊列
     * (多外部生產(chǎn)者寫入，時間輪內(nèi)的單worker消費者讀取，所以netty的實現(xiàn)里使用了效率更高的MpscQueue，Mpsc即MultiProducerSingleConsumer)
     * */
    private final Queue<MyTimeoutTaskNode> unProcessTaskQueue = new LinkedBlockingDeque<>();

    /**
     * timer持有的最低層的時間輪
     * */
    private final MyHierarchicalHashedTimeWheelV1 lowestTimeWheel;

    /**
     * 構(gòu)造函數(shù)
     * */
    public MyHierarchicalHashedTimerV1(int ringArraySize, long perTickTime, Executor taskExecutor) {
        this.perTickTime = perTickTime;

        // 初始化最底層的時間輪
        this.lowestTimeWheel = new MyHierarchicalHashedTimeWheelV1(ringArraySize,perTickTime,taskExecutor,0);
    }

    /**
     * 啟動worker線程等初始化操作，必須執(zhí)行完成后才能正常工作
     * (簡單起見，和netty不一樣不是等任務(wù)被創(chuàng)建時才懶加載的，必須提前啟動)
     * */
    @Override
    public void startTimeWheel(){
        // 啟動worker線程
        new Thread(new Worker()).start();

        while (!this.started.get()){
            // 自旋循環(huán)，等待一會
        }

        System.out.println("startTimeWheel 啟動完成:" + this.getClass().getSimpleName());
    }

    @Override
    public void newTimeoutTask(Runnable task, long delayTime, TimeUnit timeUnit){
        long deadline = System.nanoTime() + timeUnit.toNanos(delayTime);

        // Guard against overflow.
        if (delayTime > 0 && deadline < 0) {
            deadline = Long.MAX_VALUE;
        }

        MyTimeoutTaskNode newTimeoutTaskNode = new MyTimeoutTaskNode();
        newTimeoutTaskNode.setTargetTask(task);
        newTimeoutTaskNode.setDeadline(deadline);

        this.unProcessTaskQueue.add(newTimeoutTaskNode);
    }

    private final class Worker implements Runnable{

        @Override
        public void run() {
            MyHierarchicalHashedTimerV1.this.startTime = System.nanoTime();
            // 啟動
            MyHierarchicalHashedTimerV1.this.started.set(true);

            // 簡單起見，不考慮優(yōu)雅啟動和暫停的邏輯
            while (true){
                // 等待perTick
                waitForNextTick();

                // 在撈取當前tick下需要處理的bucket前，先將加入到隊列中的任務(wù)轉(zhuǎn)移到時間輪中(可能包含在當前tick下就要處理的任務(wù))
                // 層級時間輪內(nèi)部會做進一步的分配(放不下的話就溢出到更上一層的時間輪)
                transferTaskToTimeWheel();

                // 推進時間輪(層級時間輪內(nèi)部滿了一圈就會進一步的推進更上一層的時間輪)
                MyHierarchicalHashedTimerV1.this.lowestTimeWheel.advanceClockByTick(
                    (taskNode)->
                        // 參考kafka的寫法，避免Timer里的一些屬性被傳到各個bucket里面
                        MyHierarchicalHashedTimerV1.this.lowestTimeWheel
                            .addTimeoutTask(MyHierarchicalHashedTimerV1.this.startTime, taskNode)
                );

                // 循環(huán)tick一次，總tick數(shù)自增1
                MyHierarchicalHashedTimerV1.this.totalTick++;
            }
        }

        /**
         * per tick時鐘跳動，基于Thread.sleep
         * */
        private void waitForNextTick(){
            // 由于Thread.sleep并不是絕對精確的被喚醒，所以只能通過(('總的tick數(shù)+1' * '每次tick的間隔') + '時間輪啟動時間')來計算精確的下一次tick時間
            // 而不能簡單的Thread.sleep(每次tick的間隔)

            long nextTickTime = (MyHierarchicalHashedTimerV1.this.totalTick + 1) * MyHierarchicalHashedTimerV1.this.perTickTime
                + MyHierarchicalHashedTimerV1.this.startTime;

            // 因為nextTickTime是納秒，sleep需要的是毫秒，需要保證納秒數(shù)過小時，導(dǎo)致直接計算出來的毫秒數(shù)為0
            // 因此(‘實際休眠的納秒數(shù)'+999999)/1000000,保證了納秒轉(zhuǎn)毫秒時，至少會是1毫秒，而不會出現(xiàn)sleep(0毫秒)令cpu空轉(zhuǎn)
            long needSleepTime = (nextTickTime - System.nanoTime() + 999999) / 1000000;
            
            try {
                // 比起netty，忽略了一些處理特殊場景bug的邏輯
                Thread.sleep(needSleepTime);
            } catch (InterruptedException ignored) {

            }
        }

        /**
         * 加入到隊列中的任務(wù)轉(zhuǎn)移到時間輪中
         * */
        private void transferTaskToTimeWheel() {
            // 為了避免worker線程在一次循環(huán)中處理太多的任務(wù)，所以直接限制了一個最大值100000
            // 如果真的有這么多，就等到下次tick循環(huán)的時候再去做。
            // 因為這個操作是cpu密集型的，處理太多的話，可能導(dǎo)致無法在一個短的tick周期內(nèi)完成一次循環(huán)
            for (int i = 0; i < 100000; i++) {
                MyTimeoutTaskNode timeoutTaskNode = MyHierarchicalHashedTimerV1.this.unProcessTaskQueue.poll();
                if (timeoutTaskNode == null) {
                    // 隊列為空了，直接結(jié)束
                    return;
                }

                // 層級時間輪內(nèi)部會做進一步的分配(放不下的話就溢出到更上一層的時間輪)
                MyHierarchicalHashedTimerV1.this.lowestTimeWheel.addTimeoutTask(
                    MyHierarchicalHashedTimerV1.this.startTime, timeoutTaskNode);
            }
        }
    }
}

public class MyHierarchicalHashedTimeWheelV1 {

    private final MyHierarchyHashedTimeWheelBucketV1[] ringBucketArray;

    /**
     * 總tick數(shù)
     * */
    private long totalTick = 0;

    /**
     * 當前時間輪所能承載的時間間隔
     * */
    private final long interval;

    /**
     * 時間輪每次轉(zhuǎn)動的時間(單位：納秒nanos)
     * (perTickTime越短，調(diào)度會更精確，但cpu開銷也會越大)
     * */
    private final long perTickTime;

    /**
     * 上一層時間跨度更大的時間輪
     * */
    private MyHierarchicalHashedTimeWheelV1 overFlowWheel;

    /**
     * 用于實際執(zhí)行到期任務(wù)的線程池
     * */
    private final Executor taskExecutor;

    /**
     * 是否是最底層的時間輪（只有最底層的時間輪才真正的對任務(wù)進行調(diào)度）
     * */
    private final int level;

    public MyHierarchicalHashedTimeWheelV1(int ringArraySize,long perTickTime, Executor taskExecutor,int level) {
        this.ringBucketArray = new MyHierarchyHashedTimeWheelBucketV1[ringArraySize];
        for(int i=0; i<ringArraySize; i++){
            // 初始化，填充滿時間輪喚醒數(shù)組
            this.ringBucketArray[i] = new MyHierarchyHashedTimeWheelBucketV1();
        }

        this.perTickTime = perTickTime;
        this.taskExecutor = taskExecutor;
        this.interval = perTickTime * ringArraySize;
        this.level = level;

        if(level > 0){
            this.totalTick = 1;
        }
    }

    /**
     * 當前時間輪加入任務(wù)(溢出的話，則需要放到上一層的時間輪中)
     * */
    public void addTimeoutTask(long startTime, MyTimeoutTaskNode timeoutTaskNode){
        long deadline = timeoutTaskNode.getDeadline();

        // 當前時間輪所能承載的最大絕對時間為：每個tick的間隔 * 插槽數(shù) + (基于startTime的當前絕對時間)
        long currentWheelMaxRange = this.interval + (startTime + this.perTickTime * this.totalTick);

        if(deadline < currentWheelMaxRange){
            // 當前時間輪能夠承載這個任務(wù)，無需放到上一層時間輪中

            // 計算到任務(wù)超時時，應(yīng)該執(zhí)行多少次tick
            // (和netty里的不一樣，這里的deadline是超時時間的絕對時間，所以需要先減去時間輪的startTime)
            // (netty中是生產(chǎn)者線程在add時事先減去了startTime，比起由worker線程統(tǒng)一處理效率更高，但個人覺得這里的寫法會更直觀)
            long totalTickWhenTimeout = (deadline - startTime) / this.perTickTime;

            // 如果傳入的deadline早于當前系統(tǒng)時間，則totalTickWhenTimeout可能會小于當前的totalTick
            // 這種情況下，讓這個任務(wù)在當前tick下就立即超時而被調(diào)度是最合理的，而不能在求余后放到一個錯誤的位置而等一段時間才調(diào)度（所以必須取兩者的最大值）
            final long ticks = Math.max(totalTickWhenTimeout, this.totalTick); // Ensure we don't schedule for past.
            // 如果能限制環(huán)形數(shù)組的長度為2的冪，則可以改為ticks & mask，位運算效率更高
            int stopIndex = (int) (ticks % this.ringBucketArray.length);

            MyHierarchyHashedTimeWheelBucketV1 bucket = this.ringBucketArray[stopIndex];
            // 計算并找到應(yīng)該被放置的那個bucket后，將其插入當前bucket指向的鏈表中
            bucket.addTimeout(timeoutTaskNode);
        }else{
            // 當前時間輪無法承載這個任務(wù)，需要放到上一層時間輪中

            // 上層時間輪不存在，創(chuàng)建之
            if(this.overFlowWheel == null){
                // 上層時間輪的環(huán)形數(shù)組大小保持不變，perTick是當前時間輪的整個間隔(類似低層的60秒等于上一層的1分鐘)
                this.overFlowWheel = new MyHierarchicalHashedTimeWheelV1(
                    this.ringBucketArray.length, this.interval, taskExecutor,this.level+1);
            }

            // 加入到上一層的時間輪中(對于較大的deadline，addTimeoutTask操作可能會遞歸數(shù)次，放到第N層的時間輪中)
            this.overFlowWheel.addTimeoutTask(startTime,timeoutTaskNode);
        }
    }

    public void advanceClockByTick(Consumer<MyTimeoutTaskNode> flushInLowerWheelFn){
        // 基于總tick數(shù)，對環(huán)形數(shù)組的長度取模，計算出當前tick下需要處理的bucket桶的下標
        int idx = (int) (this.totalTick % this.ringBucketArray.length);

        MyHierarchyHashedTimeWheelBucketV1 bucket = this.ringBucketArray[idx];

        if(this.level == 0){
            // 如果是最底層的時間輪，將當前tick下命中的bucket中的任務(wù)丟到taskExecutor中執(zhí)行
            bucket.expireTimeoutTask(this.taskExecutor);
        }else{
            // 如果不是最底層的時間輪，將當前tick下命中的bucket中的任務(wù)交給下一層的時間輪
            // 這里轉(zhuǎn)交到下一層有兩種方式：第一種是從上到下的轉(zhuǎn)交，另一種是當做新任務(wù)一樣還是從最下層的時間輪開始放，放不下再往上溢出
            // 選用后一種邏輯，最大的復(fù)用已有的創(chuàng)建新任務(wù)的邏輯，會好理解一點
            bucket.flush(flushInLowerWheelFn);
        }

        // 當前時間輪的總tick自增1
        this.totalTick++;

        // 當前時間輪的總tick數(shù)滿了一圈之后，推進上一層時間輪進行一次tick(如果上一層時間輪存在的話)
        if(this.totalTick % this.ringBucketArray.length == 0 && this.overFlowWheel != null){
            this.overFlowWheel.advanceClockByTick(flushInLowerWheelFn);
        }
    }
}

/**
 * 時間輪環(huán)形數(shù)組下標對應(yīng)的桶(保存一個超時任務(wù)MyTimeoutTaskNode的鏈表)
 * */
public class MyHierarchyHashedTimeWheelBucketV1 {

    private final LinkedList<MyTimeoutTaskNode> linkedList = new LinkedList<>();

    public void addTimeout(MyTimeoutTaskNode timeout) {
        linkedList.add(timeout);
    }

    /**
     * 遍歷鏈表中的所有任務(wù)，round全部減一，如果減為負數(shù)了則說明這個任務(wù)超時到期了，將其從鏈表中移除后并交給線程池執(zhí)行指定的任務(wù)
     * */
    public void expireTimeoutTask(Executor executor){
        Iterator<MyTimeoutTaskNode> iterator = linkedList.iterator();
        while(iterator.hasNext()){
            MyTimeoutTaskNode currentNode = iterator.next();
            long currentNodeRound = currentNode.getRounds();
            if(currentNodeRound <= 0){
                // 將其從鏈表中移除
                iterator.remove();
                // count小于等于0，說明超時了，交給線程池去異步執(zhí)行
                executor.execute(currentNode.getTargetTask());
            }else{
                // 當前節(jié)點還未超時，round自減1
                currentNode.setRounds(currentNodeRound-1);
            }

            // 簡單起見，不考慮任務(wù)被外部自己取消的case(netty里的timeout.isCancelled())
        }
    }

    /**
     * 將當前bucket中的數(shù)據(jù)，通過flushInLowerWheelFn，全部轉(zhuǎn)移到更底層的時間輪中
     * */
    public void flush(Consumer<MyTimeoutTaskNode> flushInLowerWheelFn){
        Iterator<MyTimeoutTaskNode> iterator = linkedList.iterator();
        while(iterator.hasNext()){
            MyTimeoutTaskNode currentNode = iterator.next();
            // 先從鏈表中移除
            iterator.remove();
            // 通過flushInLowerWheelFn，轉(zhuǎn)移到更底層的時間輪中
            flushInLowerWheelFn.accept(currentNode);

            // 簡單起見，不考慮任務(wù)被外部自己取消的case(netty里的timeout.isCancelled())
        }
    }
}

public class MyHierarchicalHashedTimerV2 implements Timer {

    /**
     * 是否已啟動
     * */
    private AtomicBoolean started = new AtomicBoolean(false);

    /**
     * 關(guān)聯(lián)的最底層時間輪
     * */
    private volatile MyHierarchicalHashedTimeWheelV2 lowestTimeWheel;

    /**
     * 時間輪的啟動時間（單位:納秒）
     * */
    private long startTime;

    /**
     * 每次tick的間隔（單位:納秒）
     * */
    private final long perTickTime;

    /**
     * 時間輪的大小
     * */
    private final int timeWheelSize;

    /**
     * 用于實際執(zhí)行到期任務(wù)的線程池
     * */
    private final Executor taskExecutor;

    /**
     * 用于存儲bucket元素的延遲隊列，用于解決時間輪空轉(zhuǎn)的問題
     * */
    private final DelayQueue<MyHierarchyHashedTimeWheelBucketV2> bucketDelayQueue = new DelayQueue<>();

    public MyHierarchicalHashedTimerV2(int timeWheelSize,long perTickTime, Executor taskExecutor) {
        this.timeWheelSize = timeWheelSize;
        this.perTickTime = perTickTime;
        this.taskExecutor = taskExecutor;
    }

    /**
     * 啟動worker線程等初始化操作，必須執(zhí)行完成后才能正常工作
     * (簡單起見，和netty不一樣不是等任務(wù)被創(chuàng)建時才懶加載的，必須提前啟動)
     * */
    @Override
    public void startTimeWheel(){
        // 啟動worker線程
        new Thread(new Worker()).start();

        while (!this.started.get()){
            // 自旋循環(huán)，等待一會
        }

        System.out.println("startTimeWheel 啟動完成:" + this.getClass().getSimpleName());
    }

    @Override
    public void newTimeoutTask(Runnable task, long delayTime, TimeUnit timeUnit){
        long deadline = System.nanoTime() + timeUnit.toNanos(delayTime);

        // Guard against overflow.
        if (delayTime > 0 && deadline < 0) {
            deadline = Long.MAX_VALUE;
        }

        MyTimeoutTaskNode newTimeoutTaskNode = new MyTimeoutTaskNode();
        newTimeoutTaskNode.setTargetTask(task);
        newTimeoutTaskNode.setDeadline(deadline);

        // 加入到最底層的時間輪中，當前時間輪放不下的會溢出都上一層時間輪
        this.lowestTimeWheel.addTimeoutTask(newTimeoutTaskNode);
    }

    private void advanceClock(){
        try {
            MyHierarchyHashedTimeWheelBucketV2 bucket = this.bucketDelayQueue.take();
            lowestTimeWheel.advanceClockByTick(bucket.getExpiration());
            bucket.flush((node)->{
                // 當前選中的bucket中的任務(wù)，重新插入到時間輪中
                // 1 原本處于高層的bucket中的任務(wù)會被放到更底層
                // 2 原本就處于最低一層的bucket中的任務(wù)會被直接執(zhí)行
                this.lowestTimeWheel.addTimeoutTask(node);
            });
            // 將當前時間輪的數(shù)據(jù)
        } catch (Exception e) {
            // 忽略掉異常
            e.printStackTrace();
        }
    }


    private final class Worker implements Runnable {
        @Override
        public void run() {
            MyHierarchicalHashedTimerV2.this.startTime = System.nanoTime();

            // 初始化最底層的時間輪
            MyHierarchicalHashedTimerV2.this.lowestTimeWheel = new MyHierarchicalHashedTimeWheelV2(
                MyHierarchicalHashedTimerV2.this.startTime,
                MyHierarchicalHashedTimerV2.this.perTickTime,
                MyHierarchicalHashedTimerV2.this.timeWheelSize,
                MyHierarchicalHashedTimerV2.this.taskExecutor,
                MyHierarchicalHashedTimerV2.this.bucketDelayQueue
            );

            // 啟動
            MyHierarchicalHashedTimerV2.this.started.set(true);

            while (true){
                // 一直無限循環(huán)，不斷推進時間
                advanceClock();
            }
        }
    }
}

public class MyHierarchicalHashedTimeWheelV2 {

    /**
     * 上層時間輪（生產(chǎn)者/消費者都會訪問到，volatile修飾）
     * */
    private volatile MyHierarchicalHashedTimeWheelV2 overflowTimeWheel;

    /**
     * 每次tick的間隔（單位:納秒）
     * */
    private final long perTickTime;

    /**
     * 時間輪環(huán)形數(shù)組
     * */
    private final MyHierarchyHashedTimeWheelBucketV2[] ringBucketArray;

    /**
     * 用于實際執(zhí)行到期任務(wù)的線程池
     * */
    private final Executor taskExecutor;

    /**
     * 時間輪的當前時間
     * */
    private long currentTime;

    /**
     * 當前時間輪的間隔(每次tick的時間 * 時間輪的大小)
     * */
    private final long interval;

    private final DelayQueue<MyHierarchyHashedTimeWheelBucketV2> bucketDelayQueue;

    public MyHierarchicalHashedTimeWheelV2(long startTime, long perTickTime, int wheelSize, Executor taskExecutor,
                                           DelayQueue<MyHierarchyHashedTimeWheelBucketV2> bucketDelayQueue) {
        // 初始化環(huán)形數(shù)組
        this.ringBucketArray = new MyHierarchyHashedTimeWheelBucketV2[wheelSize];
        for(int i=0; i<wheelSize; i++){
            this.ringBucketArray[i] = new MyHierarchyHashedTimeWheelBucketV2();
        }

        // 初始化時，當前時間為startTime
        this.currentTime = startTime - (startTime % perTickTime);
        this.perTickTime = perTickTime;
        this.taskExecutor = taskExecutor;
        this.interval = perTickTime * wheelSize;
        this.bucketDelayQueue = bucketDelayQueue;
    }

    public void addTimeoutTask(MyTimeoutTaskNode timeoutTaskNode) {
        long deadline = timeoutTaskNode.getDeadline();
        if(deadline < this.currentTime + this.perTickTime){
            // 超時時間小于1tick，直接執(zhí)行
            this.taskExecutor.execute(timeoutTaskNode.getTargetTask());
        }else if(deadline < this.currentTime + this.interval){
            // 當前時間輪放的下

            // 在超時時，理論上總共需要的tick數(shù)
            long totalTick = deadline / this.perTickTime;

            // 如果傳入的deadline早于當前系統(tǒng)時間，則totalTickWhenTimeout可能會小于當前的totalTick
            // 這種情況下，讓這個任務(wù)在當前tick下就立即超時而被調(diào)度是最合理的，而不能在求余后放到一個錯誤的位置而等一段時間才調(diào)度（所以必須取兩者的最大值）
            // 如果能限制環(huán)形數(shù)組的長度為2的冪，則可以改為ticks & mask，位運算效率更高
            int stopIndex = (int) (totalTick % this.ringBucketArray.length);

            MyHierarchyHashedTimeWheelBucketV2 bucket = this.ringBucketArray[stopIndex];
            // 計算并找到應(yīng)該被放置的那個bucket后，將其插入當前bucket指向的鏈表中
            bucket.addTimeout(timeoutTaskNode);

            // deadline先除以this.perTickTime再乘以this.perTickTime,可以保證放在同一個插槽下的任務(wù)，expiration都是一樣的
            long expiration = totalTick * this.perTickTime;
            boolean isNewRound = bucket.setExpiration(expiration);
            if(isNewRound){
                this.bucketDelayQueue.offer(bucket);
            }
        }else{
            // 當前時間輪放不下
            if(this.overflowTimeWheel == null){
                createOverflowWheel();
            }

            // 加入到上層的時間輪中(較大的deadline會遞歸多次)
            this.overflowTimeWheel.addTimeoutTask(timeoutTaskNode);
        }
    }

    /**
     * 推進當前時間輪的時鐘
     * 舉個例子：假設(shè)當前時間輪的當前時間是第10分鐘，perTickTime是1分鐘，
     * 1.如果expiration是第10分鐘第1秒，則不用推動當前時間
     * 2.如果expiration是第11分鐘第0秒，則需要推動當前時間
     * */
    public void advanceClockByTick(long expiration){
        // 只會在tick推進時才會被調(diào)用，參數(shù)expiration可以認為是當前時間輪的系統(tǒng)時間
        if(expiration >= this.currentTime + this.perTickTime){
            // 超過了1tick，則需要推進當前時間輪 (始終保持當前時間是perTickTime的整數(shù)倍，邏輯上的totalTick)
            this.currentTime = expiration - (expiration % this.perTickTime);
            if(this.overflowTimeWheel != null){
                // 如果上層時間輪存在，則遞歸的繼續(xù)推進
                this.overflowTimeWheel.advanceClockByTick(expiration);
            }
        }
    }

    private synchronized void createOverflowWheel(){
        if(this.overflowTimeWheel == null){
            // 創(chuàng)建上層時間輪，上層時間輪的perTickTime = 當前時間輪的interval
            this.overflowTimeWheel = new MyHierarchicalHashedTimeWheelV2(
                this.currentTime, this.interval, this.ringBucketArray.length, this.taskExecutor, this.bucketDelayQueue);
        }
    }
}

public class MyHierarchyHashedTimeWheelBucketV2 implements Delayed {

    private final LinkedList<MyTimeoutTaskNode> taskList = new LinkedList<>();

    private final AtomicLong expiration = new AtomicLong(-1);

    public synchronized void addTimeout(MyTimeoutTaskNode timeout) {
        taskList.add(timeout);
    }

    public synchronized void flush(Consumer<MyTimeoutTaskNode> flush) {
        Iterator<MyTimeoutTaskNode> iterator = taskList.iterator();
        while (iterator.hasNext()){
            MyTimeoutTaskNode node = iterator.next();
            // 從當前bucket中移除，轉(zhuǎn)移到更下層的時間輪中
            iterator.remove();
            flush.accept(node);

            // 簡單起見，不考慮任務(wù)被外部自己取消的case(netty里的timeout.isCancelled())
        }

        this.expiration.set(-1L);
    }

    /**
     * 設(shè)置當前bucket的超時時間
     * @return 是否是一個新的bucket  true：是
     * */
    public boolean setExpiration(long expiration){
        long oldValue = this.expiration.getAndSet(expiration);

        // 如果不一樣，說明當前的expiration已經(jīng)超過了原來的expiration一圈了，邏輯上不再是同一個bucket
        return oldValue != expiration;
    }

    public long getExpiration(){
        return this.expiration.get();
    }

    @Override
    public long getDelay(TimeUnit unit) {
        // 還剩余多少時間過期
        long delayNanos = Math.max(this.expiration.get() - System.nanoTime(), 0);

        // 將納秒單位基于unit轉(zhuǎn)換
        return unit.convert(delayNanos,TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        if(o instanceof MyHierarchyHashedTimeWheelBucketV2){
            return Long.compare(this.expiration.get(),((MyHierarchyHashedTimeWheelBucketV2) o).expiration.get());
        }

        return 0;
    }
}