一個線程池 bug 引起的 GC 思考！

時間 2020-03-18

標籤一個線程 bug 引起思考欄目 Java 简体版

原文原文鏈接

做者：空無
https://segmentfault.com/a/11...

問題描述

前幾天在幫同事排查生產一個線上偶發的線程池錯誤，邏輯很簡單，線程池執行了一個帶結果的異步任務。java

可是最近有偶發的報錯：面試

java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@a5acd19 rejected from java.util.concurrent.ThreadPoolExecutor@30890a38\[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0\]

本文中的模擬代碼已經問題都是在HotSpot java8 (1.8.0_221)版本下模擬&出現的segmentfault

下面是模擬代碼，經過Executors.newSingleThreadExecutor建立一個單線程的線程池，而後在調用方獲取Future的結果後端

public class ThreadPoolTest {    public static void main(String\[\] args) {        final ThreadPoolTest threadPoolTest = new ThreadPoolTest();        for (int i = 0; i < 8; i++) {            new Thread(new Runnable() {                @Override
                public void run() {                    while (true) {

                        Future<String> future = threadPoolTest.submit();                        try {
                            String s = future.get();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } catch (ExecutionException e) {
                            e.printStackTrace();
                        } catch (Error e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }        
        //子線程不停gc，模擬偶發的gc
        new Thread(new Runnable() {            @Override
            public void run() {                while (true) {
                    System.gc();
                }
            }
        }).start();
    }    /**
     * 異步執行任務
     * @return
     */
    public Future<String> submit() {        //關鍵點，經過Executors.newSingleThreadExecutor建立一個單線程的線程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        FutureTask<String> futureTask = new FutureTask(new Callable() {            @Override
            public Object call() throws Exception {
                Thread.sleep(50);                return System.currentTimeMillis() + "";
            }
        });
        executorService.execute(futureTask);        return futureTask;
    }

}

分析&疑問

第一個思考的問題是：線程池爲何關閉了，代碼中並無手動關閉的地方。看一下Executors.newSingleThreadExecotor的源碼實現：微信

public static ExecutorService newSingleThreadExecutor() {    return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,                    0L, TimeUnit.MILLISECONDS,                    new LinkedBlockingQueue<Runnable>()));
}

這裏建立的其實是一個FinalizableDelegatedExecutorService，這個包裝類重寫了finalize函數，也就是說這個類會在被GC回收以前，先執行線程池的shutdown方法。多線程

問題來了，GC只會回收不可達（unreachable）的對象，在submit函數的棧幀未執行完出棧以前，executorService應該是可達的纔對。架構

對於此問題，先拋出結論：oracle

當對象仍存在於做用域（stack frame）時，finalize也可能會被執行less

oracle jdk文檔中有一段關於finalize的介紹：異步

A reachable object is any object that can be accessed in any potential continuing computation from any live thread.
Optimizing transformations of a program can be designed that reduce the number of objects that are reachable to be less than those which would naively be considered reachable. For example, a Java compiler or code generator may choose to set a variable or parameter that will no longer be used to null to cause the storage for such an object to be potentially reclaimable sooner.

大概意思是：可達對象(reachable object)是能夠從任何活動線程的任何潛在的持續訪問中的任何對象；java編譯器或代碼生成器可能會對再也不訪問的對象提早置爲null，使得對象能夠被提早回收

也就是說，在jvm的優化下，可能會出現對象不可達以後被提早置空並回收的狀況，關注微信公衆號：Java技術棧，在後臺回覆：java，能夠獲取我整理的 N 篇最新 Java 教程，都是乾貨。

舉個例子來驗證一下（摘自https://stackoverflow.com/questions/24376768/can-java-finalize-an-object-when-it-is-still-in-scope）：

class A {
    @Override protected void finalize() {
        System.out.println(this + " was finalized!");
    }    public static void main(String\[\] args) throws InterruptedException {
        A a = new A();
        System.out.println("Created " + a);        for (int i = 0; i < 1\_000\_000\_000; i++) {            if (i % 1\_000_00 == 0)
                System.gc();
        }
        System.out.println("done.");
    }
}//打印結果Created A@1be6f5c3
A@1be6f5c3 was finalized!//finalize方法輸出done.

從例子中能夠看到，若是a在循環完成後已經再也不使用了，則會出現先執行finalize的狀況；雖然從對象做用域來講，方法沒有執行完，棧幀並無出棧，可是仍是會被提早執行。

如今來增長一行代碼，在最後一行打印對象a，讓編譯器/代碼生成器認爲後面有對象a的引用

...System.out.println(a);//打印結果Created A@1be6f5c3
done.
A@1be6f5c3

從結果上看，finalize方法都沒有執行（由於main方法執行完成後進程直接結束了），更不會出現提早finalize的問題了

基於上面的測試結果，再測試一種狀況，在循環以前先將對象a置爲null，而且在最後打印保持對象a的引用

A a = new A();System.out.println("Created " + a);
a = null;//手動置nullfor (int i = 0; i < 1\_000\_000\_000; i++) {    if (i % 1\_000_00 == 0)        System.gc();
}System.out.println("done.");System.out.println(a);//打印結果Created A@1be6f5c3
A@1be6f5c3 was finalized!
done.null

從結果上看，手動置null的話也會致使對象被提早回收，雖然在最後還有引用，但此時引用的也是null了

如今再回到上面的線程池問題，根據上面介紹的機制，在分析沒有引用以後，對象會被提早finalize

可在上述代碼中，return以前明明是有引用的executorService.execute(futureTask)，爲何也會提早finalize呢？

猜想多是因爲在execute方法中，會調用threadPoolExecutor，會建立並啓動一個新線程，這時會發生一次主動的線程切換，致使在活動線程中對象不可達

結合上面Oracle Jdk文檔中的描述「可達對象(reachable object)是能夠從任何活動線程的任何潛在的持續訪問中的任何對象」，能夠認爲多是由於一次顯示的線程切換，對象被認爲不可達了，致使線程池被提早finalize了

下面來驗證一下猜測：

//入口函數public class FinalizedTest {    public static void main(String\[\] args) {        final FinalizedTest finalizedTest = new FinalizedTest();        for (int i = 0; i < 8; i++) {            new Thread(new Runnable() {                @Override
                public void run() {                    while (true) {
                        TFutureTask future = finalizedTest.submit();
                    }
                }
            }).start();
        }        new Thread(new Runnable() {            @Override
            public void run() {                while (true) {
                    System.gc();
                }
            }
        }).start();
    }    public TFutureTask submit(){
        TExecutorService TExecutorService = Executors.create();
        TExecutorService.execute();        return null;
    }
}//Executors.java，模擬juc的Executorspublic class Executors {    /**
     * 模擬Executors.createSingleExecutor
     * @return
     */
    public static TExecutorService create(){        return new FinalizableDelegatedTExecutorService(new TThreadPoolExecutor());
    }    static class FinalizableDelegatedTExecutorService extends DelegatedTExecutorService {

        FinalizableDelegatedTExecutorService(TExecutorService executor) {            super(executor);
        }        
        /**
         * 析構函數中執行shutdown，修改線程池狀態
         * @throws Throwable
         */
        @Override
        protected void finalize() throws Throwable {            super.shutdown();
        }
    }    static class DelegatedTExecutorService extends TExecutorService {        protected TExecutorService e;        public DelegatedTExecutorService(TExecutorService executor) {            this.e = executor;
        }        @Override
        public void execute() {
            e.execute();
        }        @Override
        public void shutdown() {
            e.shutdown();
        }
    }
}//TThreadPoolExecutor.java，模擬juc的ThreadPoolExecutorpublic class TThreadPoolExecutor extends TExecutorService {    /**
     * 線程池狀態，false：未關閉，true已關閉
     */
    private AtomicBoolean ctl = new AtomicBoolean();    @Override
    public void execute() {        //啓動一個新線程，模擬ThreadPoolExecutor.execute
        new Thread(new Runnable() {            @Override
            public void run() {

            }
        }).start();        //模擬ThreadPoolExecutor，啓動新建線程後，循環檢查線程池狀態，驗證是否會在finalize中shutdown
        //若是線程池被提早shutdown，則拋出異常
        for (int i = 0; i < 1\_000\_000; i++) {            if(ctl.get()){                throw new RuntimeException("reject!!!\["+ctl.get()+"\]");
            }
        }
    }    @Override
    public void shutdown() {
        ctl.compareAndSet(false,true);
    }
}

執行若干時間後報錯：

Exception in thread "Thread-1" java.lang.RuntimeException: reject!!!\[true\]

從錯誤上來看，「線程池」一樣被提早shutdown了，那麼必定是因爲新建線程致使的嗎？

下面將新建線程修改成Thread.sleep測試一下：

//TThreadPoolExecutor.java，修改後的execute方法public void execute() {    try {        //顯式的sleep 1 ns，主動切換線程
        TimeUnit.NANOSECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }    //模擬ThreadPoolExecutor，啓動新建線程後，循環檢查線程池狀態，驗證是否會在finalize中shutdown
    //若是線程池被提早shutdown，則拋出異常
    for (int i = 0; i < 1\_000\_000; i++) {        if(ctl.get()){            throw new RuntimeException("reject!!!\["+ctl.get()+"\]");
        }
    }
}

執行結果同樣是報錯

Exception in thread "Thread-3" java.lang.RuntimeException: reject!!!\[true\]

由此可得，若是在執行的過程當中，發生一次顯式的線程切換，則會讓編譯器/代碼生成器認爲外層包裝對象不可達

總結

雖然GC只會回收不可達GC ROOT的對象，可是在編譯器（沒有明確指出，也多是JIT）/代碼生成器的優化下，可能會出現對象提早置null，或者線程切換致使的「提早對象不可達」的狀況。

因此若是想在finalize方法裏作些事情的話，必定在最後顯示的引用一下對象（toString/hashcode均可以），保持對象的可達性（reachable）

上面關於線程切換致使的對象不可達，沒有官方文獻的支持，只是我的一個測試結果，若有問題歡迎指出

綜上所述，這種回收機制並非JDK的bug，而算是一個優化策略，提早回收而已；但Executors.newSingleThreadExecutor的實現裏經過finalize來自動關閉線程池的作法是有Bug的，在通過優化後可能會致使線程池的提早shutdown，從而致使異常。

線程池的這個問題，在JDK的論壇裏也是一個公開但未解決狀態的問題https://bugs.openjdk.java.net/browse/JDK-8145304。

不過在JDK11下，該問題已經被修復：

JUC  Executors.FinalizableDelegatedExecutorServicepublic void execute(Runnable command) {    try {
        e.execute(command);
    } finally { reachabilityFence(this); }
}

關注微信公衆號：Java技術棧，在後臺回覆：java，能夠獲取我整理的 N 篇最新 Java 教程，都是乾貨。

推薦去個人博客閱讀更多：

1.Java JVM、集合、多線程、新特性系列教程

2.Spring MVC、Spring Boot、Spring Cloud 系列教程

3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程

4.Java、後端、架構、阿里巴巴等大廠最新面試題

生活很美好，明天見～