线程池的一个BUG,被我发现了

码农突围

共 777字,需浏览 2分钟

 ·

2021-11-19 10:39

点击上方“码农突围”,马上关注

这里是码农充电第一站,回复“666”,获取一份专属大礼包
真爱,请设置“星标”或点个“在看

来源:https://urlify.cn/63QrYv
前几天,在帮同事排查一个线上偶发的线程池错误
逻辑很简单,线程池执行了一个带结果的异步任务。但是最近有偶发的报错:
  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 {


  2. public static void main(String[] args) {

  3. final ThreadPoolTest threadPoolTest = new ThreadPoolTest();

  4. for (int i = 0; i < 8; i++) {

  5. new Thread(new Runnable() {

  6. @Override

  7. public void run() {

  8. while (true) {


  9. Future<String> future = threadPoolTest.submit();

  10. try {

  11. String s = future.get();

  12. } catch (InterruptedException e) {

  13. e.printStackTrace();

  14. } catch (ExecutionException e) {

  15. e.printStackTrace();

  16. } catch (Error e) {

  17. e.printStackTrace();

  18. }

  19. }

  20. }

  21. }).start();

  22. }


  23. //子线程不停gc,模拟偶发的gc

  24. new Thread(new Runnable() {

  25. @Override

  26. public void run() {

  27. while (true) {

  28. System.gc();

  29. }

  30. }

  31. }).start();

  32. }


  33. /**

  34. * 异步执行任务

  35. * @return

  36. */

  37. public Future<String> submit() {

  38. //关键点,通过Executors.newSingleThreadExecutor创建一个单线程的线程池

  39. ExecutorService executorService = Executors.newSingleThreadExecutor();

  40. FutureTask<String> futureTask = new FutureTask(new Callable() {

  41. @Override

  42. public Object call() throws Exception {

  43. Thread.sleep(50);

  44. return System.currentTimeMillis() + "";

  45. }

  46. });

  47. executorService.execute(futureTask);

  48. return futureTask;

  49. }


  50. }

分析&疑问

第一个思考的问题是:线程池为什么关闭了,代码中并没有手动关闭的地方。看一下 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应该是可达的才对。
对于此问题,先抛出结论:
当对象仍存在于作用域(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):
  1. class A {

  2. @Override protected void finalize() {

  3. System.out.println(this + " was finalized!");

  4. }


  5. public static void main(String[] args) throws InterruptedException {

  6. A a = new A();

  7. System.out.println("Created " + a);

  8. for (int i = 0; i < 1_000_000_000; i++) {

  9. if (i % 1_000_00 == 0)

  10. System.gc();

  11. }

  12. System.out.println("done.");

  13. }

  14. }


  15. //打印结果

  16. Created A@1be6f5c3

  17. A@1be6f5c3 was finalized!//finalize方法输出

  18. done.

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

  2. System.out.println(a);


  3. //打印结果

  4. Created A@1be6f5c3

  5. done.

  6. 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);


  10. //打印结果

  11. Created A@1be6f5c3

  12. A@1be6f5c3 was finalized!

  13. done.

  14. 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. }


  30. //Executors.java,模拟juc的Executors

  31. public class Executors {

  32. /**

  33. * 模拟Executors.createSingleExecutor

  34. * @return

  35. */

  36. public static TExecutorService create(){

  37. return new FinalizableDelegatedTExecutorService(new TThreadPoolExecutor());

  38. }


  39. static class FinalizableDelegatedTExecutorService extends DelegatedTExecutorService {


  40. FinalizableDelegatedTExecutorService(TExecutorService executor) {

  41. super(executor);

  42. }


  43. /**

  44. * 析构函数中执行shutdown,修改线程池状态

  45. * @throws Throwable

  46. */

  47. @Override

  48. protected void finalize() throws Throwable {

  49. super.shutdown();

  50. }

  51. }


  52. static class DelegatedTExecutorService extends TExecutorService {


  53. protected TExecutorService e;


  54. public DelegatedTExecutorService(TExecutorService executor) {

  55. this.e = executor;

  56. }


  57. @Override

  58. public void execute() {

  59. e.execute();

  60. }


  61. @Override

  62. public void shutdown() {

  63. e.shutdown();

  64. }

  65. }

  66. }


  67. //TThreadPoolExecutor.java,模拟juc的ThreadPoolExecutor

  68. public class TThreadPoolExecutor extends TExecutorService {


  69. /**

  70. * 线程池状态,false:未关闭,true已关闭

  71. */

  72. private AtomicBoolean ctl = new AtomicBoolean();


  73. @Override

  74. public void execute() {

  75. //启动一个新线程,模拟ThreadPoolExecutor.execute

  76. new Thread(new Runnable() {

  77. @Override

  78. public void run() {


  79. }

  80. }).start();

  81. //模拟ThreadPoolExecutor,启动新建线程后,循环检查线程池状态,验证是否会在finalize中shutdown

  82. //如果线程池被提前shutdown,则抛出异常

  83. for (int i = 0; i < 1_000_000; i++) {

  84. if(ctl.get()){

  85. throw new RuntimeException("reject!!!["+ctl.get()+"]");

  86. }

  87. }

  88. }


  89. @Override

  90. public void shutdown() {

  91. ctl.compareAndSet(false,true);

  92. }

  93. }

执行若干时间后报错:
  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. }


-End-

最近有一些小伙伴,让我帮忙找一些 面试题 资料,于是我翻遍了收藏的 5T 资料后,汇总整理出来,可以说是程序员面试必备!所有资料都整理到网盘了,欢迎下载!


点击👆卡片,关注后回复【面试题】即可获取

浏览 34
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报