一個JDK線程池BUG引起的GC機制思考

問題描述

前幾天在幫同事排查生產一個線上偶發的線程池錯誤

邏輯很簡單，線程池執行了一個帶結果的異步任務。可是最近有偶發的報錯：

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)版本下模擬&出現的

下面是模擬代碼，經過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 ()));
}
這裏建立的其實是一個FinalizableDelegatedExecutorService，這個包裝類重寫了finalize函數，也就是說這個類會在被GC回收以前，先執行線程池的shutdown方法。

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

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

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

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

https://docs.oracle.com/javas...

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的優化下，可能會出現對象不可達以後被提早置空並回收的狀況

舉個例子來驗證一下（摘自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;//手動置null
for (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的Executors
public 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的ThreadPoolExecutor
public 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.FinalizableDelegatedExecutorService
public void execute(Runnable command) {
try {
e.execute(command);
} finally { reachabilityFence(this); }
}
來源：segmentfault.com/a/1190000021109130
總結了一些2020年的面試題，這份面試題的包含的模塊分爲19個模塊，分別是： Java 基礎、容器、多線程、反射、對象拷貝、Java Web 、異常、網絡、設計模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、RabbitMQ、Kafka、Zookeeper、MySQL、Redis、JVM 。

獲取資料以上資料：關注公衆號：有故事的程序員，獲取學習資料。 記得點個關注+評論哦~