线程池中的一个 BUG，注意了！！

来源：https://segmentfault.com/a/1190000021109130
问题描述

前几天在帮同事排查生产一个线上偶发的线程池错误
逻辑很简单，线程池执行了一个带结果的异步任务。但是最近有偶发的报错：

1. 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的结果

1. public class ThreadPoolTest {
3.     public static void main(String[] args) {
4.         final ThreadPoolTest threadPoolTest = new ThreadPoolTest();
5.         for (int i = 0; i < 8; i++) {
6.             new Thread(new Runnable() {
7.                 @Override
8.                 public void run() {
9.                     while (true) {
11.                         Future<String> future = threadPoolTest.submit();
12.                         try {
13.                             String s = future.get();
14.                         } catch (InterruptedException e) {
15.                             e.printStackTrace();
16.                         } catch (ExecutionException e) {
17.                             e.printStackTrace();
18.                         } catch (Error e) {
19.                             e.printStackTrace();
20.                         }
21.                     }
22.                 }
23.             }).start();
24.         }
25.         
26.         //子线程不停gc，模拟偶发的gc
27.         new Thread(new Runnable() {
28.             @Override
29.             public void run() {
30.                 while (true) {
31.                     System.gc();
32.                 }
33.             }
34.         }).start();
35.     }
37.     /**
38.      * 异步执行任务
39.      * @return
40.      */
41.     public Future<String> submit() {
42.         //关键点，通过Executors.newSingleThreadExecutor创建一个单线程的线程池
43.         ExecutorService executorService = Executors.newSingleThreadExecutor();
44.         FutureTask<String> futureTask = new FutureTask(new Callable() {
45.             @Override
46.             public Object call() throws Exception {
47.                 Thread.sleep(50);
48.                 return System.currentTimeMillis() + "";
49.             }
50.         });
51.         executorService.execute(futureTask);
52.         return futureTask;
53.     }
55. }

复制代码

分析&疑问

第一个思考的问题是：线程池为什么关闭了，代码中并没有手动关闭的地方。看一下Executors.newSingleThreadExecotor的源码实现：

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

复制代码

这里创建的实际上是一个FinalizableDelegatedExecutorService，这个包装类重写了finalize函数，也就是说这个类会在被GC回收之前，先执行线程池的shutdown方法。
问题来了，GC只会回收不可达（unreachable）的对象，在submit函数的栈帧未执行完出栈之前，executorService应该是可达的才对。
更多多线程系列教程：https://www.javastack.cn/categories/Java/
对于此问题，先抛出结论：
当对象仍存在于作用域（stack frame）时，finalize也可能会被执行
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的优化下，可能会出现对象不可达之后被提前置空并回收的情况
举个例子来验证一下，摘自：https://stackoverflow.com/questions/24376768/can-java-finalize-an-object-when-it-is-still-in-scope

1. class A {
2.     @Override protected void finalize() {
3.         System.out.println(this + " was finalized!");
4.     }
6.     public static void main(String[] args) throws InterruptedException {
7.         A a = new A();
8.         System.out.println("Created " + a);
9.         for (int i = 0; i < 1_000_000_000; i++) {
10.             if (i % 1_000_00 == 0)
11.                 System.gc();
12.         }
13.         System.out.println("done.");
14.     }
15. }
17. //打印结果
18. Created A@1be6f5c3
19. A@1be6f5c3 was finalized!//finalize方法输出
20. done.

复制代码

从例子中可以看到，如果a在循环完成后已经不再使用了，则会出现先执行finalize的情况；虽然从对象作用域来说，方法没有执行完，栈帧并没有出栈，但是还是会被提前执行。
现在来增加一行代码，在最后一行打印对象a，让编译器/代码生成器认为后面有对象a的引用

1. ...
2. System.out.println(a);
4. //打印结果
5. Created A@1be6f5c3
6. done.
7. A@1be6f5c3

复制代码

从结果上看，finalize方法都没有执行（因为main方法执行完成后进程直接结束了），更不会出现提前finalize的问题了
基于上面的测试结果，再测试一种情况，在循环之前先将对象a置为null，并且在最后打印保持对象a的引用

1. A a = new A();
2. System.out.println("Created " + a);
3. a = null;//手动置null
4. for (int i = 0; i < 1_000_000_000; i++) {
5.     if (i % 1_000_00 == 0)
6.         System.gc();
7. }
8. System.out.println("done.");
9. System.out.println(a);
11. //打印结果
12. Created A@1be6f5c3
13. A@1be6f5c3 was finalized!
14. done.
15. null

复制代码

从结果上看，手动置null的话也会导致对象被提前回收，虽然在最后还有引用，但此时引用的也是null了
现在再回到上面的线程池问题，根据上面介绍的机制，在分析没有引用之后，对象会被提前finalize
可在上述代码中，return之前明明是有引用的executorService.execute(futureTask)，为什么也会提前finalize呢？
猜测可能是由于在execute方法中，会调用threadPoolExecutor，会创建并启动一个新线程，这时会发生一次主动的线程切换，导致在活动线程中对象不可达
结合上面Oracle Jdk文档中的描述“可达对象(reachable object)是可以从任何活动线程的任何潜在的持续访问中的任何对象”，可以认为可能是因为一次显示的线程切换，对象被认为不可达了，导致线程池被提前finalize了
下面来验证一下猜想：

1. //入口函数
2. public class FinalizedTest {
3.     public static void main(String[] args) {
4.         final FinalizedTest finalizedTest = new FinalizedTest();
5.         for (int i = 0; i < 8; i++) {
6.             new Thread(new Runnable() {
7.                 @Override
8.                 public void run() {
9.                     while (true) {
10.                         TFutureTask future = finalizedTest.submit();
11.                     }
12.                 }
13.             }).start();
14.         }
15.         new Thread(new Runnable() {
16.             @Override
17.             public void run() {
18.                 while (true) {
19.                     System.gc();
20.                 }
21.             }
22.         }).start();
23.     }
24.     public TFutureTask submit(){
25.         TExecutorService TExecutorService = Executors.create();
26.         TExecutorService.execute();
27.         return null;
28.     }
29. }
31. //Executors.java，模拟juc的Executors
32. public class Executors {
33.     /**
34.      * 模拟Executors.createSingleExecutor
35.      * @return
36.      */
37.     public static TExecutorService create(){
38.         return new FinalizableDelegatedTExecutorService(new TThreadPoolExecutor());
39.     }
41.     static class FinalizableDelegatedTExecutorService extends DelegatedTExecutorService {
43.         FinalizableDelegatedTExecutorService(TExecutorService executor) {
44.             super(executor);
45.         }
46.         
47.         /**
48.          * 析构函数中执行shutdown，修改线程池状态
49.          * @throws Throwable
50.          */
51.         @Override
52.         protected void finalize() throws Throwable {
53.             super.shutdown();
54.         }
55.     }
57.     static class DelegatedTExecutorService extends TExecutorService {
59.         protected TExecutorService e;
61.         public DelegatedTExecutorService(TExecutorService executor) {
62.             this.e = executor;
63.         }
65.         @Override
66.         public void execute() {
67.             e.execute();
68.         }
70.         @Override
71.         public void shutdown() {
72.             e.shutdown();
73.         }
74.     }
75. }
77. //TThreadPoolExecutor.java，模拟juc的ThreadPoolExecutor
78. public class TThreadPoolExecutor extends TExecutorService {
80.     /**
81.      * 线程池状态，false：未关闭，true已关闭
82.      */
83.     private AtomicBoolean ctl = new AtomicBoolean();
85.     @Override
86.     public void execute() {
87.         //启动一个新线程，模拟ThreadPoolExecutor.execute
88.         new Thread(new Runnable() {
89.             @Override
90.             public void run() {
92.             }
93.         }).start();
94.         //模拟ThreadPoolExecutor，启动新建线程后，循环检查线程池状态，验证是否会在finalize中shutdown
95.         //如果线程池被提前shutdown，则抛出异常
96.         for (int i = 0; i < 1_000_000; i++) {
97.             if(ctl.get()){
98.                 throw new RuntimeException("reject!!!["+ctl.get()+"]");
99.             }
100.         }
101.     }
103.     @Override
104.     public void shutdown() {
105.         ctl.compareAndSet(false,true);
106.     }
107. }

复制代码

执行若干时间后报错：

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

复制代码

从错误上来看，“线程池”同样被提前shutdown了，那么一定是由于新建线程导致的吗？
下面将新建线程修改为Thread.sleep测试一下：

1. //TThreadPoolExecutor.java，修改后的execute方法
2. public void execute() {
3.     try {
4.         //显式的sleep 1 ns，主动切换线程
5.         TimeUnit.NANOSECONDS.sleep(1);
6.     } catch (InterruptedException e) {
7.         e.printStackTrace();
8.     }
9.     //模拟ThreadPoolExecutor，启动新建线程后，循环检查线程池状态，验证是否会在finalize中shutdown
10.     //如果线程池被提前shutdown，则抛出异常
11.     for (int i = 0; i < 1_000_000; i++) {
12.         if(ctl.get()){
13.             throw new RuntimeException("reject!!!["+ctl.get()+"]");
14.         }
15.     }
16. }

复制代码

执行结果一样是报错

1. 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下，该问题已经被修复：

1. JUC  Executors.FinalizableDelegatedExecutorService
2. public void execute(Runnable command) {
3.     try {
4.         e.execute(command);
5.     } finally { reachabilityFence(this); }
6. }

复制代码

近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！