vlambda博客
学习文章列表

线上环境，线程池BUG，让我怀疑GC机制？


获取4T架构师资料


一个JDK线程池BUG引发的GC机制思考

问题描述

前几天在帮同事排查生产一个线上偶发的线程池错误

逻辑很简单，线程池执行了一个带结果的异步任务。但是最近有偶发的报错：

  
    
    
  
    
   
     
     
   
  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]
    2.

本文中的模拟代码已经问题都是在HotSpot java8 (1.8.0_221)版本下模拟&出现的

下面是模拟代码，通过Executors.newSingleThreadExecutor创建一个单线程的线程池，然后在调用方获取Future的结果

  
    
    
  
    
   
     
     
   
  1. public class ThreadPoolTest {
    2. 
   
     
     
   

    3. 
   
     
     
   
  3.  public static void main(String[] args) {
    4. 
   
     
     
   
  4.  final ThreadPoolTest threadPoolTest = new ThreadPoolTest();
    5. 
   
     
     
   
  5.  for (int i = 0; i < 8; i++) {
    6. 
   
     
     
   
  6.  new Thread(new Runnable() {
    7. 
   
     
     
   
  7.  @Override
    8. 
   
     
     
   
  8.  public void run() {
    9. 
   
     
     
   
  9.  while (true) {
    10. 
   
     
     
   

    11. 
   
     
     
   
  11.  Future<String> future = threadPoolTest.submit();
    12. 
   
     
     
   
  12.  try {
    13. 
   
     
     
   
  13.  String s = future.get();
    14. 
   
     
     
   
  14.  } catch (InterruptedException e) {
    15. 
   
     
     
   
  15.  e.printStackTrace();
    16. 
   
     
     
   
  16.  } catch (ExecutionException e) {
    17. 
   
     
     
   
  17.  e.printStackTrace();
    18. 
   
     
     
   
  18.  } catch (Error e) {
    19. 
   
     
     
   
  19.  e.printStackTrace();
    20. 
   
     
     
   
  20.  }
    21. 
   
     
     
   
  21.  }
    22. 
   
     
     
   
  22.  }
    23. 
   
     
     
   
  23.  }).start();
    24. 
   
     
     
   
  24.  }
    25. 
   
     
     
   

    26. 
   
     
     
   
  26.  //子线程不停gc，模拟偶发的gc
    27. 
   
     
     
   
  27.  new Thread(new Runnable() {
    28. 
   
     
     
   
  28.  @Override
    29. 
   
     
     
   
  29.  public void run() {
    30. 
   
     
     
   
  30.  while (true) {
    31. 
   
     
     
   
  31.  System.gc();
    32. 
   
     
     
   
  32.  }
    33. 
   
     
     
   
  33.  }
    34. 
   
     
     
   
  34.  }).start();
    35. 
   
     
     
   
  35.  }
    36. 
   
     
     
   

    37. 
   
     
     
   
  37.  /**
    38. 
   
     
     
   
  38.  * 异步执行任务
    39. 
   
     
     
   
  39.  * @return
    40. 
   
     
     
   
  40.  */
    41. 
   
     
     
   
  41.  public Future<String> submit() {
    42. 
   
     
     
   
  42.  //关键点，通过Executors.newSingleThreadExecutor创建一个单线程的线程池
    43. 
   
     
     
   
  43.  ExecutorService executorService = Executors.newSingleThreadExecutor();
    44. 
   
     
     
   
  44.  FutureTask<String> futureTask = new FutureTask(new Callable() {
    45. 
   
     
     
   
  45.  @Override
    46. 
   
     
     
   
  46.  public Object call() throws Exception {
    47. 
   
     
     
   
  47.  Thread.sleep(50);
    48. 
   
     
     
   
  48.  return System.currentTimeMillis() + "";
    49. 
   
     
     
   
  49.  }
    50. 
   
     
     
   
  50.  });
    51. 
   
     
     
   
  51.  executorService.execute(futureTask);
    52. 
   
     
     
   
  52.  return futureTask;
    53. 
   
     
     
   
  53.  }
    54. 
   
     
     
   

    55. 
   
     
     
   
  55. }
    56.

分析&疑问

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

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

问题来了，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. 
   
     
     
   
  2.  @Override protected void finalize() {
    3. 
   
     
     
   
  3.  System.out.println(this + " was finalized!");
    4. 
   
     
     
   
  4.  }
    5. 
   
     
     
   

    6. 
   
     
     
   
  6.  public static void main(String[] args) throws InterruptedException {
    7. 
   
     
     
   
  7.  A a = new A();
    8. 
   
     
     
   
  8.  System.out.println("Created " + a);
    9. 
   
     
     
   
  9.  for (int i = 0; i < 1_000_000_000; i++) {
    10. 
   
     
     
   
  10.  if (i % 1_000_00 == 0)
    11. 
   
     
     
   
  11.  System.gc();
    12. 
   
     
     
   
  12.  }
    13. 
   
     
     
   
  13.  System.out.println("done.");
    14. 
   
     
     
   
  14.  }
    15. 
   
     
     
   
  15. }
    16. 
   
     
     
   

    17. 
   
     
     
   
  17. //打印结果
    18. 
   
     
     
   
  18. Created A@1be6f5c3
    19. 
   
     
     
   
  19. A@1be6f5c3 was finalized!//finalize方法输出
    20. 
   
     
     
   
  20. done.
    21.

从例子中可以看到，如果a在循环完成后已经不再使用了，则会出现先执行finalize的情况；虽然从对象作用域来说，方法没有执行完，栈帧并没有出栈，但是还是会被提前执行。

现在来增加一行代码，在最后一行打印对象a，让编译器/代码生成器认为后面有对象a的引用

  
    
    
  
    
   
     
     
   
  1. ...
    2. 
   
     
     
   
  2. System.out.println(a);
    3. 
   
     
     
   

    4. 
   
     
     
   
  4. //打印结果
    5. 
   
     
     
   
  5. Created A@1be6f5c3
    6. 
   
     
     
   
  6. done.
    7. 
   
     
     
   
  7. A@1be6f5c3
    8.

从结果上看，finalize方法都没有执行（因为main方法执行完成后进程直接结束了），更不会出现提前finalize的问题了

基于上面的测试结果，再测试一种情况，在循环之前先将对象a置为null，并且在最后打印保持对象a的引用

  
    
    
  
    
   
     
     
   
  1. A a = new A();
    2. 
   
     
     
   
  2. System.out.println("Created " + a);
    3. 
   
     
     
   
  3. a = null;//手动置null
    4. 
   
     
     
   
  4. for (int i = 0; i < 1_000_000_000; i++) {
    5. 
   
     
     
   
  5.  if (i % 1_000_00 == 0)
    6. 
   
     
     
   
  6.  System.gc();
    7. 
   
     
     
   
  7. }
    8. 
   
     
     
   
  8. System.out.println("done.");
    9. 
   
     
     
   
  9. System.out.println(a);
    10. 
   
     
     
   

    11. 
   
     
     
   
  11. //打印结果
    12. 
   
     
     
   
  12. Created A@1be6f5c3
    13. 
   
     
     
   
  13. A@1be6f5c3 was finalized!
    14. 
   
     
     
   
  14. done.
    15. 
   
     
     
   
  15. null
    16.

从结果上看，手动置null的话也会导致对象被提前回收，虽然在最后还有引用，但此时引用的也是null了

可在上述代码中，return之前明明是有引用的 executorService.execute(futureTask)，为什么也会提前finalize呢？

猜测可能是由于在execute方法中，会调用threadPoolExecutor，会创建并启动一个新线程，这时会发生一次主动的线程切换，导致在活动线程中对象不可达

结合上面Oracle Jdk文档中的描述“可达对象(reachable object)是可以从任何活动线程的任何潜在的持续访问中的任何对象”，可以认为可能是因为一次显示的线程切换，对象被认为不可达了，导致线程池被提前finalize了

下面来验证一下猜想：

  
    
    
  
    
   
     
     
   
  1. //入口函数
    2. 
   
     
     
   
  2. public class FinalizedTest {
    3. 
   
     
     
   
  3.  public static void main(String[] args) {
    4. 
   
     
     
   
  4.  final FinalizedTest finalizedTest = new FinalizedTest();
    5. 
   
     
     
   
  5.  for (int i = 0; i < 8; i++) {
    6. 
   
     
     
   
  6.  new Thread(new Runnable() {
    7. 
   
     
     
   
  7.  @Override
    8. 
   
     
     
   
  8.  public void run() {
    9. 
   
     
     
   
  9.  while (true) {
    10. 
   
     
     
   
  10.  TFutureTask future = finalizedTest.submit();
    11. 
   
     
     
   
  11.  }
    12. 
   
     
     
   
  12.  }
    13. 
   
     
     
   
  13.  }).start();
    14. 
   
     
     
   
  14.  }
    15. 
   
     
     
   
  15.  new Thread(new Runnable() {
    16. 
   
     
     
   
  16.  @Override
    17. 
   
     
     
   
  17.  public void run() {
    18. 
   
     
     
   
  18.  while (true) {
    19. 
   
     
     
   
  19.  System.gc();
    20. 
   
     
     
   
  20.  }
    21. 
   
     
     
   
  21.  }
    22. 
   
     
     
   
  22.  }).start();
    23. 
   
     
     
   
  23.  }
    24. 
   
     
     
   
  24.  public TFutureTask submit(){
    25. 
   
     
     
   
  25.  TExecutorService TExecutorService = Executors.create();
    26. 
   
     
     
   
  26.  TExecutorService.execute();
    27. 
   
     
     
   
  27.  return null;
    28. 
   
     
     
   
  28.  }
    29. 
   
     
     
   
  29. }
    30. 
   
     
     
   

    31. 
   
     
     
   
  31. //Executors.java，模拟juc的Executors
    32. 
   
     
     
   
  32. public class Executors {
    33. 
   
     
     
   
  33.  /**
    34. 
   
     
     
   
  34.  * 模拟Executors.createSingleExecutor
    35. 
   
     
     
   
  35.  * @return
    36. 
   
     
     
   
  36.  */
    37. 
   
     
     
   
  37.  public static TExecutorService create(){
    38. 
   
     
     
   
  38.  return new FinalizableDelegatedTExecutorService(new TThreadPoolExecutor());
    39. 
   
     
     
   
  39.  }
    40. 
   
     
     
   

    41. 
   
     
     
   
  41.  static class FinalizableDelegatedTExecutorService extends DelegatedTExecutorService {
    42. 
   
     
     
   

    43. 
   
     
     
   
  43.  FinalizableDelegatedTExecutorService(TExecutorService executor) {
    44. 
   
     
     
   
  44.  super(executor);
    45. 
   
     
     
   
  45.  }
    46. 
   
     
     
   

    47. 
   
     
     
   
  47.  /**
    48. 
   
     
     
   
  48.  * 析构函数中执行shutdown，修改线程池状态
    49. 
   
     
     
   
  49.  * @throws Throwable
    50. 
   
     
     
   
  50.  */
    51. 
   
     
     
   
  51.  @Override
    52. 
   
     
     
   
  52.  protected void finalize() throws Throwable {
    53. 
   
     
     
   
  53.  super.shutdown();
    54. 
   
     
     
   
  54.  }
    55. 
   
     
     
   
  55.  }
    56. 
   
     
     
   

    57. 
   
     
     
   
  57.  static class DelegatedTExecutorService extends TExecutorService {
    58. 
   
     
     
   

    59. 
   
     
     
   
  59.  protected TExecutorService e;
    60. 
   
     
     
   

    61. 
   
     
     
   
  61.  public DelegatedTExecutorService(TExecutorService executor) {
    62. 
   
     
     
   
  62.  this.e = executor;
    63. 
   
     
     
   
  63.  }
    64. 
   
     
     
   

    65. 
   
     
     
   
  65.  @Override
    66. 
   
     
     
   
  66.  public void execute() {
    67. 
   
     
     
   
  67.  e.execute();
    68. 
   
     
     
   
  68.  }
    69. 
   
     
     
   

    70. 
   
     
     
   
  70.  @Override
    71. 
   
     
     
   
  71.  public void shutdown() {
    72. 
   
     
     
   
  72.  e.shutdown();
    73. 
   
     
     
   
  73.  }
    74. 
   
     
     
   
  74.  }
    75. 
   
     
     
   
  75. }
    76. 
   
     
     
   

    77. 
   
     
     
   
  77. //TThreadPoolExecutor.java，模拟juc的ThreadPoolExecutor
    78. 
   
     
     
   
  78. public class TThreadPoolExecutor extends TExecutorService {
    79. 
   
     
     
   

    80. 
   
     
     
   
  80.  /**
    81. 
   
     
     
   
  81.  * 线程池状态，false：未关闭，true已关闭
    82. 
   
     
     
   
  82.  */
    83. 
   
     
     
   
  83.  private AtomicBoolean ctl = new AtomicBoolean();
    84. 
   
     
     
   

    85. 
   
     
     
   
  85.  @Override
    86. 
   
     
     
   
  86.  public void execute() {
    87. 
   
     
     
   
  87.  //启动一个新线程，模拟ThreadPoolExecutor.execute
    88. 
   
     
     
   
  88.  new Thread(new Runnable() {
    89. 
   
     
     
   
  89.  @Override
    90. 
   
     
     
   
  90.  public void run() {
    91. 
   
     
     
   

    92. 
   
     
     
   
  92.  }
    93. 
   
     
     
   
  93.  }).start();
    94. 
   
     
     
   
  94.  //模拟ThreadPoolExecutor，启动新建线程后，循环检查线程池状态，验证是否会在finalize中shutdown
    95. 
   
     
     
   
  95.  //如果线程池被提前shutdown，则抛出异常
    96. 
   
     
     
   
  96.  for (int i = 0; i < 1_000_000; i++) {
    97. 
   
     
     
   
  97.  if(ctl.get()){
    98. 
   
     
     
   
  98.  throw new RuntimeException("reject!!!["+ctl.get()+"]");
    99. 
   
     
     
   
  99.  }
    100. 
   
     
     
   
  100.  }
    101. 
   
     
     
   
  101.  }
    102. 
   
     
     
   

    103. 
   
     
     
   
  103.  @Override
    104. 
   
     
     
   
  104.  public void shutdown() {
    105. 
   
     
     
   
  105.  ctl.compareAndSet(false,true);
    106. 
   
     
     
   
  106.  }
    107. 
   
     
     
   
  107. }
    108.

执行若干时间后报错：

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

从错误上来看，“线程池”同样被提前shutdown了，那么一定是由于新建线程导致的吗？

下面将新建线程修改为 Thread.sleep测试一下：

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

执行结果一样是报错

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

由此可得，如果在执行的过程中，发生一次显式的线程切换，则会让编译器/代码生成器认为外层包装对象不可达

总结

虽然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. 
   
     
     
   
  2. public void execute(Runnable command) {
    3. 
   
     
     
   
  3.  try {
    4. 
   
     
     
   
  4.  e.execute(command);
    5. 
   
     
     
   
  5.  } finally { reachabilityFence(this); }
    6. 
   
     
     
   
  6. }
    7.
作者：空无

来源：https://urlify.cn/63QrYv

近期技术热文

1、
2、  
3、  
4、  
5、  
6、

推荐阅读

剑星 星刃 全支线任务汇总攻略-紧急信息 剑星 星刃 全支线任务汇总攻略-紧急信息
想深入了解线程池底层原理？那就动手写一个吧！ 想深入了解线程池底层原理？那就动手写一个吧！

相关文章