Java 线程池的异常处理机制

谁践踏了优雅 2022-01-15 13:27 385阅读 0赞

[为什么80%的码农都做不了架构师？>>> ][80_] ![hot3.png][]

# 一、前言 #

线程池技术是服务器端开发中常用的技术。不论是直接还是间接，各种服务器端功能的执行总是离不开线程池的调度。关于线程池的各种文章，多数是关注任务的创建和执行方面，对于异常处理和任务取消（包括线程池关闭）关注的偏少。

接下来，本文将从 Java 原生线程、两种主要线程池 `ThreadPoolExecutor` 和 `ScheduledThreadPoolExecutor` 这三方面介绍 Java 中线程的异常处理机制。

# 二、Thread #

在谈线程池的异常处理之前，我们先来看 Java 中线程中的异常是如何被处理的。大家都知道如何创建一个线程任务：

代码1

Thread t = new Thread(() -> System.out.println("Execute in a thread"));
    t.start();

为了简化代码，这里使用了 Java 8 的 Lambda 表达式。`() -> System.out.println("Execute in a thread")` 等同于在 `Runnable` 中执行 `System.out.println` 方法。后面不再解释。

如果这个任务抛出了异常，那又会怎样：

代码2

Thread t = new Thread(() -> System.out.println(1 / 0));
    t.start();

如果我们执行上面这段代码，会在控制台上看到异常输出。可能多数同学会对此不会觉得问题，但是问题在于，通常情况下绝大多数线上应用不会将控制台作为日志输出地址，而是另有日志输出。这种情况下，上面的代码所抛出异常便会丢失。

那为了将异常输出到日志中，我们会这样写代码：

代码3

Thread t = new Thread(() -> {
        try {
            System.out.println(1 / 0);
        } catch (Exception e) {
            LOGGER.error(e.getMessage(), e);
        }
    });
    t.start();

这样我们就能异常栈输出到日志中，而不是控制台，从而避免异常的丢失。

过了一段时间，问题又来了，可能好多线程任务默认的异常处理机制都是相同的。比如都是将异常输出到日志文件。按照上面的写法会造成重复代码。虽然重复的不多，但是有代码洁癖的小伙伴可能也会觉得不舒服。

那我们该如何解决这个问题呢？其实 JDK 已经为我们想到了，`Thread` 类中有个接口 `UncaughtExceptionHandler`。通过实现这个接口，并调用 `Thread.setUncaughtExceptionHandler(UncaughtExceptionHandler)` 方法，我们就能为一个线程设置默认的异常处理机制，避免重复的 `try...catch` 了。

除此以外，我们还可以通过 `Thread.setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler)` 设置全局的默认异常处理机制。此外，`ThreadGroup` 也实现了 `UncaughtExceptionHandler` 接口，所以通过 `ThreadGroup` 还可以为一组线程设置默认的异常处理机制。

其实，之所以代码2在执行之后我们能在控制台上看到异常，也是因为 `UncaughtExceptionHandler` 机制。`ThreadGroup` 默认提供了异常处理机制如下：

代码4

public void uncaughtException(Thread t, Throwable e) {
        if (parent != null) {
            parent.uncaughtException(t, e);
        } else {
            Thread.UncaughtExceptionHandler ueh =
                Thread.getDefaultUncaughtExceptionHandler();
            if (ueh != null) {
                ueh.uncaughtException(t, e);
            } else if (!(e instanceof ThreadDeath)) {
                // 最终执行如下代码
                System.err.print("Exception in thread \""
                                 + t.getName() + "\" ");
                e.printStackTrace(System.err);
            }
        }
    }

# 三、ThreadPoolExecutor #

在 Java 5 发布之后，线程池便开始越来越广泛地用于创建并发任务。多数时候，当说到 Java 的线程池时，我们一般指的就是 `ThreadPoolExecutor`。那在 `ThreadPoolExecutor` 中是如何处理异常的呢？

代码5

Executors.newSingleThreadExecutor().execute(() -> {
        throw new RuntimeException("My runtime exception");
    });

上面的代码的异常处理机制其实同直接使用 `Thread` 是一样的。所以也有同样的问题，异常信息无法反映在日志文件中。解决这个问题的方法同上一节一样：在每个 `Runnable` 中编写 `try ... catch` 语句；或者使用 `UncaughtExceptionHandler` 机制。

我们先来看如何为线程池中的工作线程设置 `UncaughtExceptionHandler`。

## 为线程池工作线程设置 UncaughtExceptionHandler ##

简单来说，就是通过 `ThreadFactory`。通过 `ThreadPoolExecutor` 的构造函数和 `Executors` 中的工具方法，我们都可以为新创建的线程池设置 `ThreadFactory`。

`ThreadFactory` 是个接口，它只定义了一个方法 `Thread newThread(Runnable r)`。在这个方法中，我们可以为新创建出来的线程设置 `UncaughtExceptionHandler`。当然，这样写起来显得很麻烦，好在 Apache Commons 和 Google Guava 这两个最有名的 Java 工具类库都为我们提供了相应的类库以简化配置 `ThreadFactory` 的工作。下面以 Apache Commons 提供的 `BasicThreadFactoryBuilder` 为例

代码6

ThreadFactory executorThreadFactory = new BasicThreadFactory.Builder()
            .namingPattern("task-scanner-executor-%d")
            .uncaughtExceptionHandler(new LogUncaughtExceptionHandler(LOGGER))
            .build();
    Executors.newSingleThreadExecutor(executorThreadFactory);

## UncaughtExceptionHandler 一定起作用吗？ ##

此话怎讲呢？其实 `ThreadPoolExecutor` 为执行并发任务提供了两种方法：`execute(Runnable)` 和 `submit(Callable/Runnable)`。之前的代码示例只演示了执行 `execute(Runnable)` 时的情况。那在设置了默认的 `UncaughtExceptionHandler` 之后，当执行 `submit(Callable/Runnable)` 方法，抛出抛异常之后有会如何？

看下面的代码

代码7

ThreadFactory threadFactory = new ThreadFactoryBuilder()
            .setUncaughtExceptionHandler(new LogExceptionHandler())
            .build();
    Executors.newSingleThreadExecutor(threadFactory)
            .submit(() -> {
                throw new RuntimeException("test");
            });

上面的程序执行完之后，不会在控制台或日志中看到任何输出，虽然设置了 `UncaughtExceptionHandler`。要弄清原因，就要看一下 `ThreadPoolExecutor` 的源代码

代码8

public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

`submit` 方法是调用 `execute` 实现任务执行的。但是在调用 `execute` 之前，任务会被封装进 `FutureTask` 类中，然后最终工作线程执行的是 `FutureTask` 中的 `run` 方法。

代码9：`FutureTask.run`

try {
        result = c.call();
        ran = true;
    } catch (Throwable ex) {
        result = null;
        ran = false;
        setException(ex);
    }
    
    protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

由上面的代码可以看出，不同于直接调用 `execute` 方法，调用 `submit` 方法后，如果任务抛出异常，会被 `setException` 方法赋给代表执行结果的 `outcome` 变量，而不会继续抛出。因此，`UncaughtExceptionHandler` 也没有机会处理。

如果想知道 `submit` 的执行结果是成功还是失败，必须调用 `Future.get()` 方法。

## UncaughtExceptionHandler 是否适合在线程池中使用 ##

从上面的分析中可以看出，使用 `UncaughtExceptionHandler`，可以处理到使用 `execute` 方法执行任务所抛出的异常，但是对 `submit` 方法无效。那如果只是用 `execute` 方法，我们是否可以通过设置 `UncaughtExceptionHandler` 从而添加一种默认的异常处理机制，以避免重复的 `try...catch` 代码呢？

答案是不能。原因在于，如果在执行 `execute` 方法时不在 `Runnable.run` 方法中写 `try...catch` 方法，自然异常会交由 `UncaughtExceptionHandler` 处理，但是，在这之前，线程的工作线程会因为异常而退出。虽然线程池会创建一个新的工作线程，但是如果这个步骤反复执行，效率自然会下降很多。

# 四、ScheduledThreadPoolExecutor #

`ScheduledThreadPoolExecutor` 是另一种常用的线程池，常用了执行延迟任务或定时任务。常用的方法为 `scheduleXXX` 系列。那在这个线程池中异常是如何处理的呢？

其实，如果看过前面的部分，到这里也基本能猜出来了。`ScheduledThreadPoolExecutor` 用来封装任务的是 `ScheduledFutureTask`。`ScheduledFutureTask` 是 `FutureTask` 的子类，所以，异常也会被复制给 `outcome`。

但是，这里还是有一些差异的。在使用 `ThreadPoolExecutor.submit` 和 `ScheduledThreadPoolExecutor.schedule` 方法时，我们可以通过这两个方法返回的 `Future` 来获得执行结果，这包括正常结果，也包括异常结果。但是，对于 `ScheduledThreadPoolExecutor.scheduleWithFixedDelay` 和 `scheduleAtFixedRate` 这两个方法，其返回的 `Future` 只会用来取消任务，而不是得到结果。原因也很容易理解，因为这两个方法执行的是定时任务，是反复执行的。这也是为什么这两个方法的任务定义使用了 `Runnable` 接口，而不是有返回值的 `Callable` 接口。因此，对于这两个方法来说，在 `Runnable.run` 方法中加 `try...catch` 是必须的，否则很有可能出错了却毫不知情。

# 五、结论 #

在 `Thread` 中，我们可以通过 `UncaughtExceptionHandler` 来实现默认的异常处理机制。但是在使用 `ThreadPoolExecutor` 和 `ScheduledThreadPoolExecutor` 这两个 JDK 最主要的线程池时，使用 `UncaughtExceptionHandler` 是不合适的。所以，`try...catch` 往往是不可避免的，否则你的任务很有可能失败的悄无声息。

转载于:https://my.oschina.net/lifany/blog/884002

[80_]: https://my.oschina.net/u/2663968/blog/3051541
[hot3.png]: /images/20220115/acccbb4508e54a3abb6d923807cb93b0.png