ScheduledThreadPoolExecutor遇到的坑

線上表象

在項目中，有一塊代碼實現了這樣的需求：使用ScheduledThreadPoolExecutor定時去拉取新增或修改的配置信息，然后加入到本地HashMap，并且往記錄表中增加一條記錄。偽代碼如下：

private static Map<String, String> cache = new HashMap<>();
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
        scheduledExecutorService.scheduleAtFixedRate(() -> loadConfig(), 10, 10, TimeUnit.SECONDS);
    }
    private static void loadConfig() {
        //1.查詢增量數據
        //2.更新map
        //3.往DB插入更新成功記錄
    }

但是有一條數據不在內存中（通過程序訪問），而且定時任務也不再執行。

解決思路

第一反應就是查看線程狀態：

 "pool-3-thread-1" #109 prio=5 os_prio=0 tid=0x00007f28bc024800 nid=0x4655 waiting on condition [0x00007f28d84f7000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000006c6750eb0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039)
        at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1081)
        at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809)
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1067)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1127)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
        at java.lang.Thread.run(Thread.java:745)

納尼，線程處于等待喚醒狀態，相應的源代碼如下：



為什么會在這里等待呢？這明顯是線程池隊列中沒有任務了嘛，具體原因這得從ScheduledThreadPoolExecutor源碼說起

ScheduledThreadPoolExecutor

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay, long period,TimeUnit unit) {
        //數據校驗
        if (command == null || unit == null)
            throw new NullPointerException();
        if (period <= 0)
            throw new IllegalArgumentException();
        //將Runnable包裝成ScheduledFutureTask
        ScheduledFutureTask<Void> sft = new ScheduledFutureTask<Void>(command, null,triggerTime(initialDelay, unit),unit.toNanos(period));
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        //延遲執行
        delayedExecute(t);
        return t;
    }

在上述代碼中，將上游傳過來的Runnable封裝成ScheduledFutureTask，ScheduledFutureTask繼承自FutureTask，線程池調度執行時，執行的即是ScheduledFutureTask中的run方法。下面來看delayedExecute方法：

private void delayedExecute(RunnableScheduledFuture<?> task) {
        if (isShutdown())
            reject(task);
        else {
            //往隊列中添加任務
            super.getQueue().add(task);
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                remove(task))
                task.cancel(false);
            else
                //預啟動線程池中的一個Worker
                ensurePrestart();
        }
    }

線程啟動后，由ScheduledThreadPoolExecutor的父類ThreadPoolExecutor接管。

ThreadPoolExecutor

在上一步的ensurePrestart啟動線程池中的Worker后，即通過Worker的run方法執行runWorker：

final void runWorker(Worker w) {
        //...
        try {
            while (task != null || (task = getTask()) != null) {
                //...
                if ((runStateAtLeast(ctl.get(), STOP) ||(Thread.interrupted() &&runStateAtLeast(ctl.get(), STOP))) &&\!wt.isInterrupted())wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    //...
                } finally {
                   //...
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

根據之前導出的線程狀態，就是從此處的getTask()開始。在消費任務的時候等待，那么肯定是生產不足導致，下面我們繼續尋找生產任務的地方。
當有任務時，會執行任務的run方法，在這里，即是ScheduledFutureTask的run方法：

public void run() {
            //是否周期調度
            boolean periodic = isPeriodic();
            //是否可運行
            if (!canRunInCurrentRunState(periodic))
                cancel(false);
            else if (!periodic)
                ScheduledFutureTask.super.run();
            //運行，并設置下次任務
            else if (ScheduledFutureTask.super.runAndReset()) {
                setNextRunTime();
                reExecutePeriodic(outerTask);
            }
        }

runAndReset代碼如下：

protected boolean runAndReset() {
        if (state != NEW || !UNSAFE.compareAndSwapObject(this,runnerOffset,null, Thread.currentThread()))
            return false;
        boolean ran = false;
        int s = state;
        try {
            Callable<V> c = callable;
            if (c != null && s == NEW) {
                try {
                    c.call(); // don't set result
                    ran = true;
                } catch (Throwable ex) {
                    setException(ex);
                }
            }
        } finally {
            runner = null;
            s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
        return ran && s == NEW;
    }

reExecutePeriodic代碼如下：

void reExecutePeriodic(RunnableScheduledFuture<?> task) {
        if (canRunInCurrentRunState(true)) {
            super.getQueue().add(task);
            if (!canRunInCurrentRunState(true) && remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }

在周期調度時，首先先執行runAndReset執行最初設置的Runnable代碼，若代碼成功執行，則返回true，否則返回false（runnable中的代碼拋出異常）。而只有當返回true時，執行reExecutePeriodic代碼，在reExecutePeriodic代碼中，super.getQueue().add(task)即是任務的生產。而當runAndReset返回false時，則不再往Queue中添加task，此時再執行getTask()中的take()時，由于隊列為空，所以線程變為等待喚醒，但已沒有任何地方再添加task，所以不再定時調度。

結論

通過查看scheduleAtFixedRate的jdk文檔，有一句如下：

If any execution of the task encounters an exception, subsequent executions are suppressed.
如果在任務的執行中遇到異常，后續執行被取消。

不禁有個疑問，為什么要這么設計呢？這次任務失敗并不一定意味著下一次會失敗啊。
個人是這樣的看法：java不想去猜你的異常會怎樣，要求你必須把自己的異常處理好，這樣讓自己更專注的做調度，而無須關心調度的邏輯。

ScheduledThreadPoolExecutor的最優實踐：
將所有執行代碼用try-cache包裹，如下：

private static Map<String, String> cache = new HashMap<>();
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
        scheduledExecutorService.scheduleAtFixedRate(() -> loadConfig(), 10, 10, TimeUnit.SECONDS);
    }
    private static void loadConfig() {
        try {
            //1.查詢增量數據
            //2.更新map
            //3.往DB插入更新成功記錄
        } catch (Exception e) {
            //異常處理
        }
    }
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 文章摘要：在業務系統中，線程池框架技術一直是用來解決多線程并發的一種有效方法。 在JDK中，J.U.C并發包下的T...
    癲狂俠閱讀 2,119評論 2贊 21
  • 線程池的概念和定義 在服務器端的業務應用開發中，Web服務器(諸如Tomcat、Jetty)需要接受并處理http...
    dtdh閱讀 846評論 0贊 1
  • 我很小的時候，尤愛糯米飯澆醬油吃，但身體方面偏又不爭氣的很，吃不得些醬辣油滾的東西，總上火。記得有一回清明，奶奶跟...
    木叚Mujia閱讀 562評論 3贊 4
  • O 價值網絡對于個人而言，我理解就是一個人的人際關系網。就是人們現在常常掛在嘴邊的圈子，作為社會人，每一個個體都有...
    果果親閱讀 595評論 0贊 1
  • 出國前我在南京的一家報社里做旅游版記者，我每天努力的跑稿子寫稿子，終于等到了組版的時候，一整版的鋪天蓋地的廣告把我...
    Thebookworm新西蘭閱讀 674評論 20贊 17