在我们平时开发过程中,使用线程异步进行业务逻辑处理是比较常见的异步处理方法。但是如果在我们的异步线程中发生了异常该怎么处理呢,本文将学习如何处理异步线程抛出的异常如果进行捕获处理。学习本文之前,请优先对线程池的原理和使用场景有一定的了解。
异步线程异常模拟
开发中,我们常常会用到线程池,但任务一旦提交到线程池之后,如果发生异常之后,怎么处理?怎么获取到异常信息?我们知道线程池的提交方式: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("运行异常");
}
}
执行结果: