SOFAJRaft原始碼閱讀-Netty時間輪演算法的實踐

yuan發表於2023-01-29

SOFAJRaft的定時任務排程器是基於Netty來實現的,所以本文將會基於Netty時間輪演算法,然後再結合SOFAJRaft原始碼進行分析。
@Author:Akai-yuan
@更新時間:2023/1/29

1.HashedWheelTimer概覽

一個時間輪演算法的組成成分圖:
一個基於Netty實現的時間輪(HashedWheelTimer)有三個核心部分:HashedWheelTimeout(任務封裝)、HashedWheelBucket(任務連結串列)、Worker(任務執行執行緒)

屬性概覽

HashedWheelTimer欄位的具體作用全部以註釋的形式標記在以下程式碼塊中。
我們可以先看看HashedWheelTimer的屬性,看不懂沒有關係,可以先大致瞭解一下一個時間輪的屬性有些什麼。

	//日誌
	private static final Logger LOG = LoggerFactoryLoggerFactory.getLogger(HashedWheelTimer.class);
    //例項數量限制為256
	private static final int INSTANCE_COUNT_LIMIT   = 256;
	//例項計數器
    private static final AtomicInteger instanceCounter = new AtomicInteger();
	//超過例項最大數量後是否警告標識,配合INSTANCE_COUNT_LIMIT欄位使用
    private static final AtomicBoolean warnedTooManyInstances = new AtomicBoolean();
	//原子更新欄位類,用於原子更新workerState屬性
    private static final AtomicIntegerFieldUpdater<HashedWheelTimer> workerStateUpdater = 
        AtomicIntegerFieldUpdater.newUpdater(HashedWheelTimer.class,"workerState");
	//繼承自Runnable,Worker是整個時間輪的執行流程管理者
    private final Worker worker = new Worker();
	//工作執行緒
    private final Thread workerThread;
	//工作狀態碼常量類【0 - init, 1 - started, 2 - shut down】
    public static final int WORKER_STATE_INIT      = 0;
    public static final int WORKER_STATE_STARTED   = 1;
    public static final int WORKER_STATE_SHUTDOWN  = 2;
	//工作狀態碼
    @SuppressWarnings({ "unused", "FieldMayBeFinal" })
    private volatile int workerState;
 	// tick的時長,也就是指標多久轉一格
    private final long tickDuration;
	//時間輪陣列,每個位置是一個HashedWheelBucket
    private final HashedWheelBucket[] wheel;
	//定址識別符號用於快速定址
	//公式:mask==wheel.length-1
	//原理:當x=2^n(n為自然數)時 a%x=a&(x-1)
    private final int mask;
    //一個等待startTime初始化的計數器
    private final CountDownLatch startTimeInitialized   = new CountDownLatch(1);
	//用來暫時存放待加入時間輪的任務的佇列
    private final Queue<HashedWheelTimeout> timeouts = new ConcurrentLinkedQueue<>();
	//用來暫時存放已被取消的任務的佇列
    private final Queue<HashedWheelTimeout> cancelledTimeouts = new ConcurrentLinkedQueue<>();
    //未執行任務的計數器
	private final AtomicLong pendingTimeouts = new AtomicLong(0);
    //未執行任務的最大數量
	private final long maxPendingTimeouts;
    //開始時間
	private volatile long startTime;

構造器概覽

這個構造器裡面主要做一些初始化的工作。

  1. 初始化一個陣列長度為2048的Wheel時間輪。由於傳入的陣列長度可能為Big Number,所以我去SOFAJRaft上提了一個issue,建議採用JAVA8-HashMap的相關實現來完善該演算法,可見於:ISSUE-時間輪演算法存在多迴圈低效率問題
  2. 初始化mask,用來快速計算槽位的下標。
  3. 初始化tickDuration並轉化成納秒
  4. 校驗整個時間輪走完的時間不能過長
  5. 將worker包裝成thread
  6. 限制HashedWheelTimer例項數量
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的冪,並初始化輪子
        wheel = createWheel(ticksPerWheel);
        //定址識別符號
        mask = wheel.length - 1;
        //將tickDuration(時間單位為unit)轉換為納秒
        this.tickDuration = unit.toNanos(tickDuration);
        //防止溢位,指標轉動的時間間隔不能超過:Long.MAX_VALUE/wheel.length
        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包裝成thread
        workerThread = threadFactory.newThread(worker);
    	//預設-1
        this.maxPendingTimeouts = maxPendingTimeouts;
    	//如果HashedWheelTimer例項太多,會列印error日誌
        if (instanceCounter.incrementAndGet() > INSTANCE_COUNT_LIMIT
            && warnedTooManyInstances.compareAndSet(false, true)) {
            reportTooManyInstances();
        }
    }

實現原理圖:

HashedWheelTimer是整個時間輪演算法的核心類,透過指定的Hash規則將不同TimeOut定時任務劃分到HashedWheelBucket進行管理,而HashedWheelBucket利用雙向連結串列結構維護了某一時刻需要執行的定時任務列表。

接上文SOFAJRaft原始碼閱讀-模組啟動過程,我們知道,在NodeImpl#init方法中,構造了多個RepeatedTimer例項:voteTimer、electionTimer、stepDownTimer、snapshotTimer。並且重寫了RepeatedTimer#onTrigger和RepeatedTimer#adjustTimeout兩個方法。緊接著,NodeImpl中的多個方法(如:init、electSelf、becomeLeader)會對這些RepeatedTimer例項呼叫RepeatedTimer#start方法啟動。

2.啟動計時器

  • 加ReentrantLock鎖,保證只能一個執行緒呼叫這個方法
  • 啟動狀態引數校驗
  • 呼叫RepeatedTimer#schedule方法
  • 釋放鎖
    public void start() {
        this.lock.lock();
        try {
            if (this.destroyed) {
                return;
            }
            if (!this.stopped) {
                return;
            }
            this.stopped = false;
            if (this.running) {
                return;
            }
            this.running = true;
            schedule();
        } finally {
            this.lock.unlock();
        }
    }

3.任務排程

RepeatedTimer#start中會呼叫RepeatedTimer#schedule:

  • 如果RepeatedTimer中維護的HashedWheelTimeout(任務)不為空,則取消(HashedWheelTimer#cancel)該任務。
  • 宣告一個TimerTask,並透過HashedWheelTimer#newTimeout()構造一個HashedWheelTimeout
private void schedule() {
        if (this.timeout != null) {
            this.timeout.cancel();
        }
        final TimerTask timerTask = timeout -> {
            try {
                //執行onTrigger,並設定狀態引數
                RepeatedTimer.this.run();
            } catch (final Throwable t) {
                LOG.error("Run timer task failed, taskName={}.", RepeatedTimer.this.name, t);
            }
        };
        this.timeout = this.timer.newTimeout(timerTask, adjustTimeout(this.timeoutMs), TimeUnit.MILLISECONDS);
    }

HashedWheelTimer#cancel:
取消一個任務,並將其放入另一個cancelledTimeouts佇列

public boolean cancel() {
    		//只更新將在下一刻從HashedWheelBucket中刪除的狀態
           	if (!compareAndSetState(ST_INIT, ST_CANCELLED)) {
                return false;
            }
    		//如果一個任務應該被取消,我們將其放入另一個cancelledTimeouts佇列,該佇列將在每次tick時處理。
			//因此,這意味著我們將有一個GC延遲,最大為1個tick的持續時間,這已經足夠好了。
    		//這樣,我們可以再次使用MpscLinkedQueue,從而儘可能減少鎖定/開銷。
            timer.cancelledTimeouts.add(this);
            return true;
        }

4.往時間輪內新增任務

重點理解HashedWheelTimer#newTimeout:

  • 判空
  • 校驗pendingTimeoutsCount引數的合理性,如果maxPendingTimeouts(最大的等待加入的任務的數量)為0或負數,則表示不需要對pendingTimeoutsCount進行數量限制,否則會進行比較,超過限制則會丟擲異常。
  • 呼叫HashedWheelTimer#start()啟動時間輪。
  • 計算當前新增任務的執行時間。傳入的delay引數由RepeatedTimer#adjustTimeout(this.timeoutMs)獲取
  • 防溢位操作
  • 最後將任務加入佇列,此時還未加入到時間輪中,需要等待時鐘撥動(也就是當呼叫鏈路HashedWheelTimer#start->workerThread#start->Worker#run->waitForNextTick返回了引數時)才會觸發往時間輪內新增任務
    public Timeout newTimeout(TimerTask task, long delay, TimeUnit unit) {
        if (task == null) {
            throw new NullPointerException("task");
        }
        if (unit == null) {
            throw new NullPointerException("unit");
        }
        //等待的任務數 +1
        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();
        // 計算當前新增任務的執行時間
        long deadline = System.nanoTime() + unit.toNanos(delay) - startTime;
        // 防止溢位
        if (delay > 0 && deadline < 0) {
            deadline = Long.MAX_VALUE;
        }
        // 將任務加入佇列(注意,此時還未加入到時間輪中)
        HashedWheelTimeout timeout = new HashedWheelTimeout(this, task, deadline);
        timeouts.add(timeout);
        return timeout;
    }

5.開啟時間輪內的執行緒

我們知道,新新增的任務會先儲存在timeouts佇列中,當時間輪的時鐘撥動時才會判斷是否將佇列中的任務載入進時間輪。那麼工作執行緒開啟後,start() 方法會被阻塞,等工作執行緒(workerThread.start())的 startTime 屬性初始化完成後才被喚醒。
因為上面的 newTimeout 方法線上程開啟後【start()】,需要計算當前新增進來任務的執行時間【long deadline = System.nanoTime() + unit.toNanos(delay) - startTime;】,而這個執行時間是根據 startTime 計算的。
HashedWheelTimer#start:

  • 判斷當前時間輪的狀態,如果是初始化,則啟動worker執行緒,啟動整個時間輪;如果已經啟動則略過;如果是已經停止,則報錯。
  • 如果初始化未完成,則需要等待worker執行緒完成startTime的初始化
    public void start() {
    // Lock Free設計。可能有多個執行緒呼叫啟動方法,這裡使用AtomicIntegerFieldUpdater原子的更新時間輪的狀態,
    // 它是JUC裡面的類,利用反射進行原子操作。有比AtomicInteger更好的效能和更低得記憶體佔用
        switch (workerStateUpdater.get(this)) {
            case WORKER_STATE_INIT:
                if (workerStateUpdater.compareAndSet(this, WORKER_STATE_INIT, WORKER_STATE_STARTED)) {
                    workerThread.start();
                }
                break;
            case WORKER_STATE_STARTED:
                break;
            case WORKER_STATE_SHUTDOWN:
                throw new IllegalStateException("cannot be started once stopped");
            default:
                throw new Error("Invalid WorkerState");
        }
    	// startTimeInitialized 是一個 CountDownLatch,目的是為了保證工作執行緒的 startTime 屬性初始化
        // startTime的初始化和startTimeInitialized.countDown()方法會在Worker#run
        // [也就是workerThread.start()中]完成
        while (startTime == 0) {
            try {
                startTimeInitialized.await();
            } catch (InterruptedException ignore) {
                // Ignore - it will be ready very soon.
            }
        }
    }

6.時間輪排程

**
時間輪每撥動一次就會觸發tick++,然後tick與mask(時間輪陣列長度 - 1)進行 & 運算,可以快速定位時間輪陣列內的槽【mask定址識別符號用於快速定址,其原理:當x=2^n(n為自然數)時 a%x=a&(x-1)】。因為 tick 值一直在增加,所以時間輪陣列看起來就像一個不斷迴圈的圓。

  • 先初始化 startTime 值,因為後面任務執行的時間是根據 startTime 計算的
  • 時鐘撥動,如果時間未到,則 sleep 一會兒
  • 處理過期的任務
  • 將任務載入進時間輪
  • 執行當前時鐘對應時間輪內的任務
  • 時間輪關閉,將所有未執行的任務封裝到 unprocessedTimeouts 集合中,在 stop 方法中返回出去
  • 處理過期的任務
public void run() {
            // 初始化 startTime
            startTime = System.nanoTime();
            if (startTime == 0) {
                startTime = 1;
            }

            // 用來喚醒被阻塞的 HashedWheelTimer#start() 方法,保證 startTime 初始化
            startTimeInitialized.countDown();

            do {
                // 時鐘撥動,有返回值(必須是正數)的時候說明可以撥動時鐘了
                final long deadline = waitForNextTick();
                if (deadline > 0) {
                    int idx = (int) (tick & mask);
                    // 處理過期的任務
                    processCancelledTasks();
                    HashedWheelBucket bucket = wheel[idx];
                    // 將任務載入進時間輪
                    transferTimeoutsToBuckets();
                    // 執行當前時間輪槽內的任務
                    bucket.expireTimeouts(deadline);
                    tick++;
                }
            } while (workerStateUpdater.get(HashedWheelTimer.this) == WORKER_STATE_STARTED);

            // 時間輪關閉,將還未執行的任務以列表的形式儲存到 unprocessedTimeouts 集合中,在 stop 方法中返回出去
            // 還未執行的任務可能會在兩個地方,一:時間輪陣列內,二:佇列中
            for (HashedWheelBucket bucket : wheel) {
                bucket.clearTimeouts(unprocessedTimeouts);
            }
            for (;;) {
                HashedWheelTimeout timeout = timeouts.poll();
                if (timeout == null) {
                    break;
                }
                if (!timeout.isCancelled()) {
                    unprocessedTimeouts.add(timeout);
                }
            }
            processCancelledTasks();
        }

7.時間撥動

Worker#waitForNextTick:

  • 當時鍾撥動一次後,應該計算下一次時鐘撥動的時間
  • 獲取當前時間的相對時間
  • 計算距離時鐘下次撥動的時間,也就是sleepTimeMs。這裡之所以加 999999 後再除 10000000, 是為了保證足夠的 sleep 時間。例如:當 deadline - currentTime = 2000002 的時候,如果不加 999999,則只睡了 2ms。而 2ms 其實是未到達 deadline 時間點的,所以為了使上述情況能 sleep 足夠的時間,加上 999999 後,會多睡 1ms。
  • 如果還沒到就 sleep 一會兒,等到撥動時間再醒來。
  • 進入下一次迴圈,直到sleepTimeMs<=0 說明可以撥動時鐘了
        private long waitForNextTick() {
            // 計算時鐘下次撥動的相對時間
            long deadline = tickDuration * (tick + 1);

            for (;;) {
                // 獲取當前時間的相對時間
                final long currentTime = System.nanoTime() - startTime;
                // 計算距離時鐘下次撥動的時間
                long sleepTimeMs = (deadline - currentTime + 999999) / 1000000;
            	// <=0 說明可以撥動時鐘了
                if (sleepTimeMs <= 0) {
                    if (currentTime == Long.MIN_VALUE) {
                        return -Long.MAX_VALUE;
                    } else {
                        return currentTime;
                    }
                }
            	// sleep 到下次時鐘撥動
                try {
                    Thread.sleep(sleepTimeMs);
                } catch (InterruptedException ignored) {
                    if (workerStateUpdater.get(HashedWheelTimer.this) == WORKER_STATE_SHUTDOWN) {
                        return Long.MIN_VALUE;
                    }
                }
            }
        }

8.移除取消的任務

Worker#processCancelledTasks:

  • 遍歷cancelledTimeouts中所有例項並從其對應HashedWheelBucket中移除。
  • 在呼叫HashedWheelTimer的stop方法的時候會將要取消的HashedWheelTimeout例項放入到cancelledTimeouts佇列中,所以這裡只需要迴圈把佇列中的資料取出來,然後呼叫HashedWheelTimeout的remove方法將自己在bucket移除就好了。
        private void processCancelledTasks() {
            //遍歷cancelledTimeouts中所有例項並從其對應HashedWheelBucket中移除
            for (;;) {
                HashedWheelTimeout timeout = cancelledTimeouts.poll();
                if (timeout == null) {
                    // all processed
                    break;
                }
                try {
                    timeout.remove();
                } catch (Throwable t) {
                    if (LOG.isWarnEnabled()) {
                        LOG.warn("An exception was thrown while process a cancellation task", t);
                    }
                }
            }
        }

9.將任務從佇列載入進時間輪

Worker#transferTimeoutsToBuckets:
在上面也提到過,任務剛加進來不會立即到時間輪中去,而是暫時儲存到一個佇列中,當時間輪時鐘撥動時,會將任務從佇列中載入進時間輪內。

  • 每次呼叫這個方法會處理10w個任務,以免阻塞worker執行緒
  • 從timeouts中取出任務
  • 在校驗之後會用timeout的deadline除以每次tick執行的時間tickDuration得出需要經過多少次時鐘撥動才會執行這個timeout的任務
  • 計算時間輪撥動的圈數。由於timeout的deadline實際上還包含了worker執行緒啟動到timeout加入佇列這段時間,所以在算remainingRounds的時候需要減去當前的tick次數。
  • 將任務載入進時間輪對應的槽內,可能有多個任務經過 hash 計算後定位到同一個槽,這些任務會以雙向連結串列的結構儲存,有點類似 HashMap 處理碰撞的情況。
        private void transferTimeoutsToBuckets() {
            // 一次最多隻處理佇列中的 100000 個任務
            for (int i = 0; i < 100000; i++) {
                HashedWheelTimeout timeout = timeouts.poll();
                if (timeout == null) {
                    // all processed
                    break;
                }
                // 過濾已經取消的任務
                if (timeout.state() == HashedWheelTimeout.ST_CANCELLED) {
                    // Was cancelled in the meantime.
                    continue;
                }
				// 計算當前任務到執行還需要經過幾次時鐘撥動
                // 假設時間輪陣列大小是 10,calculated 為 12,需要時間輪轉動一圈加兩次時鐘撥動後後才能執行這個任務,因此還需要計算一下圈數
                long calculated = timeout.deadline / tickDuration;
                // 計算當前任務到執行還需要經過幾圈時鐘撥動
                timeout.remainingRounds = (calculated - tick) / wheel.length;
				// 有的任務可能在佇列裡很長時間,時間過期了也沒有被排程,將這種情況的任務放在當前輪次內執行
                final long ticks = Math.max(calculated, tick); // Ensure we don't schedule for past.
                // 計算任務在時間輪陣列中的槽
                int stopIndex = (int) (ticks & mask);

                HashedWheelBucket bucket = wheel[stopIndex];
                // 將任務放到時間輪的陣列中,多個任務可能定位時間輪的同一個槽,這些任務透過以連結串列的形式連結
                bucket.addTimeout(timeout);
            }
        }

10.執行任務

HashedWheelBucket#expireTimeouts:
時間輪槽內的任務以連結串列形式儲存,這些任務執行的時間可能會不一樣,有的在當前時鐘執行,有的在下一圈或者之後幾圈對應的時鐘才會執行。當任務在當前時鐘執行時,需要將這個任務從連結串列中刪除,重新維護連結串列關係。

        public void expireTimeouts(long deadline) {
            HashedWheelTimeout timeout = head;

            // process all timeouts
            while (timeout != null) {
                HashedWheelTimeout next = timeout.next;
                // 任務執行的圈數 > 0,表示任務還需要經過 remainingRounds 圈時鐘迴圈才能執行
                if (timeout.remainingRounds <= 0) {
                    // 從連結串列中移除當前任務,並返回連結串列中下一個任務
                    next = remove(timeout);
                    if (timeout.deadline <= deadline) {
                        // 執行任務
                        timeout.expire();
                    } else {
                        // The timeout was placed into a wrong slot. This should never happen.
                        throw new IllegalStateException(String.format("timeout.deadline (%d) > deadline (%d)",
                            timeout.deadline, deadline));
                    }
                } else if (timeout.isCancelled()) {
                    // 過濾取消的任務
                    next = remove(timeout);
                } else {
                    // 圈數 -1
                    timeout.remainingRounds--;
                }
                timeout = next;
            }
        }

HashedWheelTimeout#expire:

  • CAS切換任務狀態
  • task.run(this)執行任務
        public void expire() {
            // CAS任務狀態變換
            if (!compareAndSetState(ST_INIT, ST_EXPIRED)) {
                return;
            }

            try {
                task.run(this);
            } catch (Throwable t) {
                if (LOG.isWarnEnabled()) {
                    LOG.warn("An exception was thrown by " + TimerTask.class.getSimpleName() + '.', t);
                }
            }
        }

11.終止時間輪

**HashedWheelTimer#stop(): **
觸發終止時間輪的鏈路為:NodeImpl#destroyAllTimers()->RepeatedTimer#destroy()->timer.stop()

  • 當終止時間輪時,將時間輪的狀態修改為 WORKER_STATE_SHUTDOWN。時間輪狀態有兩種情況:(1)WORKER_STATE_INIT:當初始化時間輪物件時並不會立即開啟時間輪工作執行緒,而是第一次新增任務時才開啟,此狀態表示時間輪沒有處理過任務(2)WORKER_STATE_STARTED:時間輪在工作,這裡也有兩種情況,存在併發與不存在併發,如果多個執行緒都嘗試終止時間輪,肯定只能有一個成功。
  • 時間輪停止執行後會將未執行的任務返回出去,至於怎麼處理這些任務,由業務方自己定義,這個流程和執行緒池的 shutdownNow 方法是類似的。
  • 如果時間輪在執行,如果時間輪處於非執行狀態,會把時間輪陣列與佇列中未執行且未取消的任務儲存到 unprocessedTimeouts 集合中。而終止時間輪成功的執行緒只需要等待一會兒,這個等待透過 workerThread.join(100)實現。
    public Set<Timeout> stop() {
        // 終止時間輪的執行緒不能是時間輪的工作執行緒
        if (Thread.currentThread() == workerThread) {
            throw new IllegalStateException(HashedWheelTimer.class.getSimpleName() + ".stop() cannot be called from "
                                            + TimerTask.class.getSimpleName());
        }
        // 將時間輪的狀態修改為 WORKER_STATE_SHUTDOWN,這裡有兩種情況
        // 一:時間輪是 WORKER_STATE_INIT 狀態,表明時間輪從建立到終止一直沒有任務進來
        // 二:時間輪是 WORKER_STATE_STARTED 狀態,多個執行緒嘗試終止時間輪,只有一個操作成功
        if (!workerStateUpdater.compareAndSet(this, WORKER_STATE_STARTED, WORKER_STATE_SHUTDOWN)) {
            // 程式碼走到這裡,時間輪只能是兩種狀態中的一個,WORKER_STATE_INIT 和 WORKER_STATE_SHUTDOWN
            // 為 WORKER_STATE_INIT 表示時間輪沒有任務,因此不用返回未處理的任務,但是需要將時間輪例項 -1
            // 為 WORKER_STATE_SHUTDOWN 表示是 CAS 操作失敗,什麼都不用做,因為 CAS 成功的執行緒會處理
            if (workerStateUpdater.getAndSet(this, WORKER_STATE_SHUTDOWN) != WORKER_STATE_SHUTDOWN) {
                 // 時間輪例項物件 -1
                instanceCounter.decrementAndGet();
            }
        	// CAS 操作失敗,或者時間輪沒有處理過任務,返回空的任務列表
            return Collections.emptySet();
        }

        try {
            boolean interrupted = false;
            while (workerThread.isAlive()) {
                // 中斷時間輪工作執行緒
                workerThread.interrupt();
                try {
                    // 終止時間輪的執行緒等待時間輪工作執行緒 100ms,這個過程主要是為了時間輪工作執行緒處理未執行的任務
                    workerThread.join(100);
                } catch (InterruptedException ignored) {
                    interrupted = true;
                }
            }

            if (interrupted) {
                Thread.currentThread().interrupt();
            }
        } finally {
            instanceCounter.decrementAndGet();
        }
        // 返回未處理的任務
        return worker.unprocessedTimeouts();
    }

寫在後面

SOFAJRaft採用的是Netty的時間輪演算法來實現任務排程器,但是Netty的時間輪演算法存在一定缺陷,比如:它是透過單執行緒實現的,如果在執行任務的過程中出現阻塞,會影響後面任務執行。Netty 中的時間輪並不適合建立延遲時間跨度很大的任務,比如往時間輪內丟成百上千個任務並設定 10 天后執行,這樣可能會導致連結串列過長 round 值很大,而且這些任務在執行之前會一直佔用記憶體。
到這裡SOFAJRaft的定時任務排程器就差不多完整的走了一遍,第一遍看確實很容易懵逼,但是再讀幾遍還是會感覺很有成就感的。作者總結完這篇文章,差不多剛過完年,希望後面能繼續堅持下去。

相關文章