### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

### 起因
- 一個基於Spring Cloud框架的應用，如果註冊到了Eureka server，那麼它就會定時更新服務列表，這個定時任務啟動的程式碼在com.netflix.discovery.DiscoveryClient類的initScheduledTasks方法中，如下（來自工程eureka-client，版本1.7.0）：

```java
private void initScheduledTasks() {
		//更新服務列表
        if (clientConfig.shouldFetchRegistry()) {
            // registry cache refresh timer
            int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
            int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
            scheduler.schedule(
                    new TimedSupervisorTask(
                            "cacheRefresh",
                            scheduler,
                            cacheRefreshExecutor,
                            registryFetchIntervalSeconds,
                            TimeUnit.SECONDS,
                            expBackOffBound,
                            new CacheRefreshThread()
                    ),
                    registryFetchIntervalSeconds, TimeUnit.SECONDS);
        }
		...
		//略去其他程式碼
```

- 上述程式碼中，scheduler是ScheduledExecutorService介面的實現，其schedule方法的[官方文件](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ScheduledExecutorService.html)如下所示：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220619/1655638991603877718.png)

- 上圖紅框顯示：該方法建立的是**一次性任務**，但是在實際測試中，如果在CacheRefreshThread類的run方法中打個斷點，就會發現該方法會被週期性呼叫；

- 因此問題就來了：方法**schedule(Callable<v> callable,long delay,TimeUnit unit)**建立的明明是個**一次性任務**，但CacheRefreshThread被**週期性執行了**；

### 尋找答案
- 開啟的run方法原始碼，請注意下面的中文註釋：

```java
public void run() {
        Future future = null;
        try {
	    //使用Future，可以設定子執行緒的超時時間，這樣當前執行緒就不用無限等待了
            future = executor.submit(task);
            threadPoolLevelGauge.set((long) executor.getActiveCount());
            //指定等待子執行緒的最長時間
            future.get(timeoutMillis, TimeUnit.MILLISECONDS);  // block until done or timeout
            //delay是個很有用的變數，後面會用到，這裡記得每次執行任務成功都會將delay重置
            delay.set(timeoutMillis);
            threadPoolLevelGauge.set((long) executor.getActiveCount());
        } catch (TimeoutException e) {
            logger.error("task supervisor timed out", e);
            timeoutCounter.increment();

long currentDelay = delay.get();
            //任務執行緒超時的時候，就把delay變數翻倍，但不會超過外部呼叫時設定的最大延時時間
            long newDelay = Math.min(maxDelay, currentDelay * 2);
            //設定為最新的值，考慮到多執行緒，所以用了CAS
            delay.compareAndSet(currentDelay, newDelay);
        } catch (RejectedExecutionException e) {
            //一旦執行緒池的阻塞佇列中放滿了待處理任務，觸發了拒絕策略，就會將排程器停掉
            if (executor.isShutdown() || scheduler.isShutdown()) {
                logger.warn("task supervisor shutting down, reject the task", e);
            } else {
                logger.error("task supervisor rejected the task", e);
            }

rejectedCounter.increment();
        } catch (Throwable e) {
            //一旦出現未知的異常，就停掉排程器
            if (executor.isShutdown() || scheduler.isShutdown()) {
                logger.warn("task supervisor shutting down, can't accept the task");
            } else {
                logger.error("task supervisor threw an exception", e);
            }

throwableCounter.increment();
        } finally {
            //這裡任務要麼執行完畢，要麼發生異常，都用cancel方法來清理任務；
            if (future != null) {
                future.cancel(true);
            }
            
	    //只要排程器沒有停止，就再指定等待時間之後在執行一次同樣的任務
            if (!scheduler.isShutdown()) {
            	//這裡就是週期性任務的原因：只要沒有停止排程器，就再建立一次性任務，執行時間時dealy的值，
            	//假設外部呼叫時傳入的超時時間為30秒（構造方法的入參timeout），最大間隔時間為50秒(構造方法的入參expBackOffBound)
            	//如果最近一次任務沒有超時，那麼就在30秒後開始新任務，
            	//如果最近一次任務超時了，那麼就在50秒後開始新任務（異常處理中有個乘以二的操作，乘以二後的60秒超過了最大間隔50秒）
                scheduler.schedule(this, delay.get(), TimeUnit.MILLISECONDS);
            }
        }
    }
```
- 真相就在上面的最後一行程式碼中：**scheduler.schedule(this, delay.get(), TimeUnit.MILLISECONDS)**：執行完任務後，會再次呼叫schedule方法，在指定的時間之後執行一次相同的任務，這個間隔時間和最近一次任務是否超時有關，如果超時了就間隔時間就會變大；

- 小結：從整體上看，TimedSupervisorTask是固定間隔的週期性任務，一旦遇到超時就會將下一個週期的間隔時間調大，如果連續超時，那麼每次間隔時間都會增大一倍，一直到達外部引數設定的上限為止，一旦新任務不再超時，間隔時間又會自動恢復為初始值，另外還有CAS來控制多執行緒同步，簡潔的程式碼，巧妙的設計，值得我們學習；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</v>

Eureka的TimedSupervisorTask類（自動調節間隔的週期性任務）

相關文章