线程池中线程抛了异常处理

        在我们平时开发过程中，使用线程异步进行业务逻辑处理是比较常见的异步处理方法。但是如果在我们的异步线程中发生了异常该怎么处理呢，本文将学习如何处理异步线程抛出的异常如果进行捕获处理。学习本文之前，请优先对线程池的原理和使用场景有一定的了解。

异步线程异常模拟

        开发中，我们常常会用到线程池，但任务一旦提交到线程池之后，如果发生异常之后，怎么处理？怎么获取到异常信息？我们知道线程池的提交方式：submit和execute的区别，接下来分别使用他们执行带有异常的任务！看看效果！

代码模拟场景如下：

/**
 * 线程任务类
 */
class ThreadTask implements  Runnable{

    @Override
    public void run() {
        System.out.println("进入了ThreadTask方法！！！");
        throw new RuntimeException();
    }
}

利用线程池执行线程

    public static void main(String[] args) {

        //创建一个固定大小的线程池
        ExecutorService executorService= Executors.newFixedThreadPool(1);

        //当线程池抛出异常后 submit无提示，其他线程继续执行
        executorService.submit(new ThreadTask());

        //当线程池抛出异常后 execute抛出异常，其他线程继续执行新任务
        executorService.execute(new ThreadTask());
    }

执行结果如下：

 很显然submit线程执行了，但是异常信息并未打印，然而execute会打印异常信息，但是在时间开发过程中，我们无法保障我们的线程执行方法内部永远不会抛出异常，如果使用submit方式执行线程后，我们无法捕获run执行方法异常，做出业务判断和处理，所以我们需要知道如何捕获线程异常。

submit中submit.get()会等待submit提交的任务完成后，才取回结果，往下执行。

get()方法尽量放在业务代码最后调用，以便于submit提交的任务在执行计算的同时，业务代码也在执行。但是如果submit提交的任务，一直阻塞（比如，远程调用服务、网络原因），那么主线程调用get()也会跟着被阻塞，造成请求时间过长，用户体验相当不好！如何解决呢？submit也提供了对应的API!可以设置等待超时时间。

V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

 既然submit.get()会返回结果，那么我们抛出的异常信息，是不是也会打印呢。

果然入预期结果一致。方法在submit.get()处异常后，后续方法不在执行了。由此可见submit也是可以使用get方法获取到方法异常信息。

如何获取和处理异常

        1. 使用try....catch进行方法执行体异常捕获处理  

package com.cat.sleep.util.date;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @Title: ThreadPoolException
 * @Package com.cat.sleep.util.date
 * @Description: 线程池异常测试
 * @Date: 2022年10月25日 13:40:10
 * @Copyright: 2022
 */
public class ThreadPoolExceptionTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //创建一个固定大小的线程池
        ExecutorService executorService= Executors.newFixedThreadPool(1);

        //当线程池抛出异常后 submit无提示，其他线程继续执行
        Future<?> submit = executorService.submit(new ThreadTask());
        submit.get();

        //当线程池抛出异常后 execute抛出异常，其他线程继续执行新任务
        executorService.execute(new ThreadTask());

        executorService.shutdown();
    }
}

/**
 * 线程任务类
 */
class ThreadTask implements  Runnable{

    @Override
    public void run() {
        try {
            System.out.println("进入了ThreadTask方法！！！");
            throw new RuntimeException();
        } catch (RuntimeException e) {
            System.out.println("我异常了呗！！！" + e);
        }
    }
}

执行结果如下

可以看到 submit 和 execute都清晰易懂的捕获到了异常，可以知道我们的任务出现了问题。 

        2. 使用Thread.setDefaultUncaughtExceptionHandler方法捕获异常

重写UncaughtExceptionHandler异常处理方法

/**
 * @Title: MyUnchecckedExceptionhandler
 * @Package com.cat.sleep.util.date
 * @Description: TODO
 * @Date: 2022年10月25日 15:24:55
 * @Copyright: 2022
 */
public class MyUnchecckedExceptionhandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("捕获异常处理方法：" + e.getMessage());
    }
}

应用线程池方法:

/**
 * @Title: ThreadPoolException
 * @Package com.cat.sleep.util.date
 * @Description: 线程池异常测试
 * @Date: 2022年10月25日 13:40:10
 * @Copyright: 2022
 */
public class ThreadPoolExceptionTest1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //1.实现一个自己的线程池工厂
        ThreadFactory factory = r -> {
            Thread thread = new Thread(r);
            Thread.setDefaultUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
            return thread;
        };
        //创建一个自己定义的线程池，使用自己定义的线程工厂
        ExecutorService executorService= new ThreadPoolExecutor(1,1,0, TimeUnit.MICROSECONDS, new LinkedBlockingQueue<>(10), factory);

        //当线程池抛出异常后 submit无提示，其他线程继续执行
//        executorService.submit(new ThreadTask1());

        Future<?> submit = executorService.submit(new ThreadTask1());
        //打印异常结果
//        System.out.println(submit.get());

        Thread.sleep(1000);
        System.out.println("==================");

        //当线程池抛出异常后 execute抛出异常，其他线程继续执行新任务
        executorService.execute(new ThreadTask1());

        executorService.shutdown();
    }
}

/**
 * 线程任务类
 */
class ThreadTask1 implements  Runnable{

    @Override
    public void run() {
        System.out.println("进入了ThreadTask方法！！！");
        throw new RuntimeException("运行异常");
    }
}

执行结果：

 当我们在执行submit的时候，没有执行get方法时，发现异常信息并没有打印。我们知道，execute和submit最大的区别就是execute没有返回值，submit有返回值。submit返回的是一个future ，可以通过这个future取到线程执行的结果或者异常信息。

Future<?> submit = executorService.submit(new task());
//打印异常结果
System.out.println(submit.get()); 

然后就能输入我们打印的异常信息了，但是在使用过程中发现get方法获取到异常信息时，线程被挂起，如果不设置超时时间，后续方法不会继续执行

 异常捕获后不影响后续方法执行

        Future<?> submit = executorService.submit(new ThreadTask1());
        //打印异常结果
        try {
            System.out.println(submit.get(1, TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }

 

 为什么我们不执行get方法就不好打印异常日志呢，具体请查看submit方法源码：

ExecutorService.submit=>AbstractExecutorService.submit=>ThreadPoolExecutor=>Worker.run()

        3. 重写afterExecute进行异常处理

/**
 * @Title: ThreadPoolException
 * @Package com.cat.sleep.util.date
 * @Description: 线程池异常测试
 * @Date: 2022年10月25日 13:40:10
 * @Copyright: 2022
 */
public class ThreadPoolExceptionTest2 {
    public static void main(String[] args) throws InterruptedException {

        //创建一个自己定义的线程池，使用自己定义的线程工厂
        ExecutorService executorService= new ThreadPoolExecutor(1,1,0, TimeUnit.MICROSECONDS, new LinkedBlockingQueue<>(10)){
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                //这个是excute提交的时候
                if (t != null) {
                    System.out.println("afterExecute里面获取到excute提交的异常信息，处理异常" + t.getMessage());
                }
                //如果r的实际类型是FutureTask 那么是submit提交的，所以可以在里面get到异常
                if (r instanceof FutureTask) {
                    try {
                        Future<?> future = (Future<?>) r;
                        //get获取异常
                        future.get();
                    } catch (Exception e) {
                        System.out.println("afterExecute里面获取到submit提交的异常信息，处理异常" + e);
                    }
                }
            }
        };

        //当线程池抛出异常后 submit无提示，其他线程继续执行
//        executorService.submit(new ThreadTask2());

        Future<?> submit = executorService.submit(new ThreadTask2());
        //打印异常结果
        try {
            System.out.println(submit.get(1, TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }

        Thread.sleep(1000);
        System.out.println("==================");

        //当线程池抛出异常后 execute抛出异常，其他线程继续执行新任务
        executorService.execute(new ThreadTask2());

        executorService.shutdown();
    }
}

/**
 * 线程任务类
 */
class ThreadTask2 implements  Runnable{

    @Override
    public void run() {
        System.out.println("进入了ThreadTask方法！！！");
        throw new RuntimeException("运行异常");
    }
}

执行结果：