记一次因线程池 BUG 引起的问题分析

本文正在参加「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) 版本下模拟&出现的

下面是模拟代码，通过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应该是可达的才对。

对于此问题，先抛出结论：

当对象仍存在于作用域（stack frame）时，finalize也可能会被执行

oracle jdk文档中有一段关于finalize的介绍：

https://docs.oracle.com/javase/specs/jls/se8/html/jls-12.html#jls-12.6.1

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 的优化下（JIT），可能会出现对象不可达之后被提前置空并回收的情况

写个例子来验证一下（摘自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了

既然是 JIT 的原因，那么禁用 JIT 试试呢？是不是就不会出现这个问题了？

果然……配置-Xint禁用 JIT 之后，上面的问题就没了，就是 JIT 的“锅。”

那么再回到上面的线程池问题，根据上面介绍的机制，在分析没有引用之后，对象会被提前finalize。

executorService.execute(futureTask) 这个算是引用吗？JIT 可不一定这么认为……在 JIT 的优化下，会把 executorService 提前置空，导致 GC 前 finalized 被调用，线程池执行 shutdown……所以导致了最终的问题

关于这个“提前置空”的 JIT 机制，可以看看R大的详细解释

总结

虽然 GC 只会回收不可达 GC ROOT 的对象，但是在 JIT 的优化下，可能会出现对象提前置 null 的情况。

所以如果想在finalize方法里做些事情的话，一定在最后显示的引用一下对象，保持对象的可达性（reachable）。

如果没有特殊需求的话，我们只需要记住有这个 JIT 优化，至于 JIT 编译器的优化细节，有兴趣的就看看 R 大的百科吧

综上所述，JIT 这种优化并不是 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); }
}

记一次因线程池 BUG 引起的问题分析原创

问题描述

分析&疑问

总结

参考

本月精选性能专题

本月精选线上案例

本月精选原创好文

联系我们

网媒渠道

友情链接