捕获异步线程异常的常用方式

最新推荐文章于 2024-08-14 08:45:00 发布
最新推荐文章于 2024-08-14 08:45:00 发布
阅读量7k 收藏 14
点赞数 1
分类专栏： 多线程与高并发 文章标签： 捕获线程异常 线程异常处理 处理线程异常 java多线程 多线程异常处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justry_deng/article/details/105877524
版权

声明： 捕获异步线程异常的方式有很多，本文只介绍(并示例)几种相对常用的方式。

捕获异步线程异常的常用方式(结论)：

开启线程的方式使用线程池的情况捕获异步线程异常的常用方式
Thread不使用线程池1. Thread.setDefaultUncaughtExceptionHandler设置默认的线程异常处理器。
2. Thread实例.setUncaughtExceptionHandler给当指定线程设置线程异常处理器。
Thread使用线程池ExecutorService#execute1. Thread.setDefaultUncaughtExceptionHandler设置默认的线程异常处理器。
2.自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常。
3. 自定义ThreadFactory， 重写newThread方法，给线程工厂生产出来的Thread实例设置UncaughtExceptionHandler。
Thread使用线程池ExecutorService#submit自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常。
Runnable不使用线程池1. Thread.setDefaultUncaughtExceptionHandler设置默认的线程异常处理器。
2. Thread实例.setUncaughtExceptionHandler给当指定线程设置线程异常处理器。
Runnable使用线程池ExecutorService#execute1. Thread.setDefaultUncaughtExceptionHandler设置默认的线程异常处理器。
2. 自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常。
3. 自定义ThreadFactory， 重写newThread方法，给线程工厂生产出来的Thread实例设置UncaughtExceptionHandler。
Runnable使用线程池ExecutorService#submit自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常。
Callable不使用线程池在使用Future#get()方法获取Callable#call()的返回结果时， try-catch获取异常。
注：此方式，若不使用Future#get()获取结果，那么 异步线程的异常信息将会被吞掉。
Callable使用线程池ExecutorService#submit自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常。

捕获异步线程异常的常用方式(示例说明)：

提示： 完整测试项目可见文末链接。
准备工作：

  • 一个Thread
    在这里插入图片描述
  • 一个Runnable
    在这里插入图片描述
  • 一个Callable
    在这里插入图片描述
  • 一个UncaughtExceptionHandler
    在这里插入图片描述
  • 一个ThreadPoolExecutor
    在这里插入图片描述
  • 一个自定义的ThreadFactory
    在这里插入图片描述

Thread不使用线程池：

  • 方式一：Thread.setDefaultUncaughtExceptionHandler
    /**
 * [不使用线程池]方式一: Thread.setDefaultUncaughtExceptionHandler 设置默认的线程异常处理器
 */
private static void testThread1() {
    Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
    MyThread myThread = new MyThread();
    myThread.start();
}
  • 方式二：Thread实例.setUncaughtExceptionHandler
    /**
 * [不使用线程池]方式二: Thread实例.setUncaughtExceptionHandler 给当指定线程设置线程异常处理器
 */
private static void testThread2() {
    MyThread myThread = new MyThread();
    myThread.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
    myThread.start();
}

Thread使用线程池ExecutorService#execute：

  • 方式一：Thread.setDefaultUncaughtExceptionHandler
    /**
 * [使用线程池execute]方式一: Thread.setDefaultUncaughtExceptionHandler 设置默认的线程异常处理器
 */
private static void testThread3() {
    Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
    ExecutorService executorService = Executors.newFixedThreadPool(3);
    MyThread myThread = new MyThread();
    executorService.execute(myThread);
}
  • 方式二：自定义ThreadPoolExecutor， 重写afterExecute方法
    /**
 * [使用线程池execute]方式二: 自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常
 */
private static void testThread4() {
    ExecutorService executorService = new MyThreadPoolExecutor(5,
            50, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<>(20),
            Thread::new, new ThreadPoolExecutor.AbortPolicy());
    MyThread myThread = new MyThread();
    executorService.execute(myThread);
}
  • 方式三：自定义ThreadFactory， 给线程工厂生产出来的Thread实例设置UncaughtExceptionHandler
    /**
 * [使用线程池execute]方式三: 自定义ThreadFactory， 重写newThread方法，给线程工厂生
 *                          产出来的Thread实例设置UncaughtExceptionHandler
 */
private static void testThread5() {
    ExecutorService executorService = new ThreadPoolExecutor(5,
            50, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<>(20),
            new MyThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
    MyThread myThread = new MyThread();
    executorService.execute(myThread);
}

Thread使用线程池ExecutorService#submit：

  • 方式：自定义ThreadPoolExecutor， 重写afterExecute方法
    /**
 * [使用线程池submit]方式一: 自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常
 */
private static void testThread6() {
    ExecutorService executorService = new MyThreadPoolExecutor(5,
            50, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<>(20),
            Thread::new, new ThreadPoolExecutor.AbortPolicy());
    MyThread myThread = new MyThread();
    executorService.submit(myThread);
}

Runnable不使用线程池：

  • 方式一：Thread.setDefaultUncaughtExceptionHandler
    /**
 * [不使用线程池]方式一: Thread.setDefaultUncaughtExceptionHandler 设置默认的线程异常处理器
 */
private static void testRunnable1() {
    Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
    MyRunnable myRunnable = new MyRunnable();
    new Thread(myRunnable).start();
}
  • 方式二：Thread实例.setUncaughtExceptionHandler
    /**
 * [不使用线程池]方式二: Thread实例.setUncaughtExceptionHandler 给当指定线程设置线程异常处理器
 */
private static void testRunnable2() {
    MyRunnable myRunnable = new MyRunnable();
    Thread thread = new Thread(myRunnable);
    thread.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
    thread.start();
}

Runnable使用线程池ExecutorService#execute：

  • 方式一：Thread.setDefaultUncaughtExceptionHandler
    /**
 * [使用线程池execute]方式一: Thread.setDefaultUncaughtExceptionHandler 设置默认的线程异常处理器
 */
private static void testRunnable3() {
    Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
    ExecutorService executorService = Executors.newFixedThreadPool(3);
    MyRunnable myRunnable = new MyRunnable();
    executorService.execute(myRunnable);
}
  • 方式二：自定义ThreadPoolExecutor， 重写afterExecute方法
    /**
 * [使用线程池execute]方式二: 自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常
 */
private static void testRunnable4() {
    ExecutorService executorService = new MyThreadPoolExecutor(5,
            50, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<>(20),
            Thread::new, new ThreadPoolExecutor.AbortPolicy());
    MyRunnable myRunnable = new MyRunnable();
    executorService.execute(myRunnable);
}
  • 方式三：自定义ThreadFactory， 给线程工厂生产出来的Thread实例设置UncaughtExceptionHandler
    /**
 * [使用线程池execute]方式三: 自定义ThreadFactory， 重写newThread方法，给线程工厂生
 *                          产出来的Thread实例设置UncaughtExceptionHandler
 */
private static void testRunnable5() {
    ExecutorService executorService = new ThreadPoolExecutor(5,
            50, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<>(20),
            new MyThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
    MyRunnable myRunnable = new MyRunnable();
    executorService.execute(myRunnable);
}

Runnable使用线程池ExecutorService#submit：

  • 方式：自定义ThreadPoolExecutor， 重写afterExecute方法
    	/**
	 * [使用线程池submit]方式一: 自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常
	 */
	private static void testRunnable6() {
	    ExecutorService executorService = new MyThreadPoolExecutor(5,
	            50, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<>(20),
	            Thread::new, new ThreadPoolExecutor.AbortPolicy());
	    MyRunnable myRunnable = new MyRunnable();
	    executorService.submit(myRunnable);
	}

Callable不使用线程池：

  • 方式：在使用Future#get()方法获取Callable#call()的返回结果时， try-catch获取异常
    /**
 * [不使用线程池]: 在使用Future#get()方法获取Callable#call()的返回结果时， try-catch获取异常
 *
 * 注: 此方式， 若不使用Future#get()获取结果，那么 异步线程的异常信息将会被吞掉
 */
private static void testCallable1() throws InterruptedException {
    MyCallable myCallable = new MyCallable();
    FutureTask<Object> futureTask = new FutureTask<> (myCallable);
    Thread thread = new Thread(futureTask);
    thread.start();
    try {
        // 在尝试获取结果时，捕获异常
        Object o = futureTask.get();
    } catch (ExecutionException e) {
        Throwable cause = e.getCause();
        log.error(" callable-thread occur exception", cause);
    }
}

Callable使用线程池ExecutorService#submit：

  • 方式：自定义ThreadPoolExecutor， 重写afterExecute方法
    /**
 * [使用线程池submit]: 自定义ThreadPoolExecutor， 重写afterExecute方法，在afterExecute方法中感知异常
 */
private static void testCallable2() {
    ExecutorService executorService = new MyThreadPoolExecutor(5,
            50, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<>(20),
            Thread::new, new ThreadPoolExecutor.AbortPolicy());
    MyCallable myCallable = new MyCallable();
    executorService.submit(myCallable);
}

^_^ 如有不当之处，欢迎指正

^_^ 测试代码托管链接
         https://github.com/JustryDeng…CatchSyncThreadException…

^_^ 本文已经被收录进《程序员成长笔记》 ，笔者JustryDeng

justry_deng
关注
专栏目录
子线程任务发生异常，主线程事务如何回滚
03-10
子线程任务发生异常，主线程事务如何回滚
详解Java中多线程异常捕获Runnable的实现
08-29
主要介绍了详解Java中多线程异常捕获Runnable的实现的相关资料,希望通过本文能帮助到大家，让大家理解掌握这样的知识，需要的朋友可以参考下
c#基础-异步方法的异常处理
最新发布
weixin_72925698的博客
08-14 896
除了前面提到的异步方法异常处理的基本知识点，以下是一些进阶的异常处理技巧：在异步方法中，如果需要将异常传递给调用方，请不要直接抛出异常。相反，应该使用 throw 关键字将异常包装在一个Task或ValueTask对象中，并将其返回给调用方。这可以避免在异步操作中丢失异常信息。如果需要在异步方法中处理多个异常，可以使用catch块来捕获不同类型的异常，并根据需要执行不同的处理操作。还可以使用finally块来执行清理操作，例如释放资源或恢复状态。
关于捕获异步线程异常
u011196623的专栏
02-24 648
关于Async注解异步异常捕获 @Async public void test(Event event) { int result= 1/0; } @Configuration public cl...
精读《捕获所有异步 error》
前端精读周刊
09-06 193
成熟的产品都有较高的稳定性要求，仅前端就要做大量监控、错误上报，后端更是如此，一个未考虑的异常可能导致数据错误、服务雪崩、内存溢出等等问题，轻则每天焦头烂额的处理异常，重则引发线上故障。假...
SpringBoot异步方法捕捉异常
.
09-22 4678
由于项目中定时器都采用异步执行方式 需要定时监控异步方法执行进度，异常情况 1 执行进度 可以设置是否在执行，内存中添加执行标识即可。 防止多次执行可以通过拦截器对此，标识来判断，防止多次执行定时器 2 异常捕捉 监控异步方法执行是否异常。 1 无返回值 配置AsyncExceptionConfig类，统一处理。 定义异常捕获配置类AsyncExceptionConfig，配置类里面定义Sprin...
捕获异常的两种方式
weixin_30954265的博客
07-04 133
捕获异常的两种方式 方法一 #coding=utf-8 import sys try: with open("ddd.txt", "r") as f: data = f.read() print data except: err = sys.exc_info() print err sys.exc_inf...
03. 异步线程创建-Thread 方式
Java 程序源
09-01 2071
1. 核心内容 直接继承Thread类是创建异步线程最简单的方式, 但并不常用. 匿名内部类的方式可以考虑. 1.1 继承Thread 方式特点 开发简单, 可直接通过this.获取线程的相关信息 违背了面向接口编程原则, 需直接继承Thread类, 不利于扩展. 不推荐使用 主线程不能监控子线程何时结束, 也不能获取子线程返回结果 切记启动异步线程的方式是调用star()方法, 而非调用run...
04. 异步线程创建-Runnable 方式
Java 程序源
09-01 4836
1. 核心内容 直接继承Thread类是创建异步线程最简单的方式, 但并不常用. 匿名内部类的方式可以考虑. 1.1 继承Thread 方式特点 开发简单, 可直接通过this.获取线程的相关信息 违背了面向接口编程原则, 需直接继承Thread类, 不利于扩展. 不推荐使用 主线程不能监控子线程何时结束, 也不能获取子线程返回结果 切记启动异步线程的方式是调用star()方法, 而非调用run...
Java多线程【异步编排】
大脑不能为空
10-13 3934
Java线程和进程的区别，为什么要有线程池，JUC并发编程教程。
深入探索 Python 中的多线程与异步编程（实用技巧与最佳实践）
mrdeam的博客
05-22 995
本文深入探讨了Python中的多线程编程和异步编程，涵盖了多线程模块（threading）的基础知识、代码实战，以及异步编程模块（asyncio）的基本概念和使用。我们从多线程的基础，如Thread类、锁机制、线程安全等开始，逐步展示了多线程在实际应用中的应用场景和注意事项。通过一个实例展示了多线程下载图片的过程，强调了线程安全和异常处理的重要性。随后，本文引入了异步编程的概念，通过协程、async和await关键字，以及asyncio模块的使用，向读者展示了异步编程的基础。
Springboot @Async 异步线程的异常捕获和处理的两种方式
milugloomy的博客
12-11 9989
a
并发编程 --- 异步方法的异常处理
Gefangenes的博客
08-07 244
除了前面提到的异步方法异常处理的基本知识点，以下是一些进阶的异常处理技巧：在异步方法中，如果需要将异常传递给调用方，请不要直接抛出异常。相反，应该使用 throw 关键字将异常包装在一个Task或ValueTask对象中，并将其返回给调用方。这可以避免在异步操作中丢失异常信息。如果需要在异步方法中处理多个异常，可以使用catch块来捕获不同类型的异常，并根据需要执行不同的处理操作。还可以使用finally块来执行清理操作，例如释放资源或恢复状态。
不是吧？async/await异常捕获你还在用try-catch～
我本可以容忍阳光，如果我不曾见过太阳，然而阳光已使我荒凉，成为更新的荒凉。
05-26 440
写在前面不知道大家项目里面是怎么处理 async/await 的异常，我斗胆在我们项目里翻了一下，发现大量使用 try-catch 来处理 async/await 异常。try-awati-catch.png首先说明一下， try-catch 处理并没有什么问题，我只是觉得这么写代码会有点乱，感觉代码逻辑像是断层了一样，不易理解；其次是代码冗余问题，单个 try-catch 就占了好几行代码，如果...
java 捕获线程异常处理_捕获Java线程池执行任务抛出的异常
weixin_36147027的博客
02-13 547
Java中线程执行的任务接口java.lang.Runnable 要求不抛出Checked异常，publicinterfaceRunnable{publicabstractvoidrun();}那么如果 run() 方法中抛出了RuntimeException，将会怎么处理了？通常java.lang.Thread对象运行设置一个默认的异常处理方法：java.lang.Thread.setDefa...
异步线程异常逃逸
Dkangel的博客
05-31 370
由于异步线程池没有配置 UncaughtExceptionHandler，当异步线程执行过程中发生异常时将不会被捕获，造成异常逃逸现象。
java sleep异常_java 注意线程下的 异常捕获，sleep(10000)休眠，可能会出现***循环...
weixin_29607629的博客
02-12 1185
https://blog..net/persistencegoing/article/details/84376427线程(1)在catch(){} 中的语句要保证不会出现异常，或者catch中的语句再次捕获了异常，( 2 ) 线程中try中的语句出现异常，会直接跳过try中的sleep，导致不停地循环(3)线程的while循环中如果不适用try catch 会导致当出现异常时，线程直接挂掉，pa...
c# 并发与异步 一、线程创建 汇合 休眠 阻塞
学以致用 知行合一
01-19 1529
线程是抢占式的。它的执行和其他线程的代码是交错执行的。这个术语通常可以解释一些由此而产生的问题。 线程一旦启动，其IsAlive属性就会返回true，直至线程停止。当Thread的构造函数接收的委托执行完毕之后，线程就会停止。线程停止之后就无法再启动了。 每一个线程都有一个Name属性用作调试用途。这个属性在Visual Studio中尤其有用，因为线程的名称会显示在“Thread”窗口和“Debug Location”工具栏上。线程的名称只能够设置一次，试图修改线程的名
setUncaughtExceptionHandler捕获异常线程
enthan809882的博客
02-06 2488
线程中的异常有点特殊。直接加try catch是捕获不到的。因为try catch的当前线程是main线程。 异常实在线程里面发生的，不属于main线程。 直接用try catch捕获不到异常： public class ThreadExceptionDemo implements Runnable{ @Override public void run() { Sy...
Async 异步调用方法？
04-03
异步调用是一种编程模型，用于处理需要长时间执行的操作，以避免阻塞主线程或其他任务。在异步调用中，任务会在后台执行，而不会阻塞当前线程的执行。 在C#中，Async/await是一种常用的异步编程模型。以下是Async异步调用的一般步骤： 1. 定义一个异步方法：使用`async`关键字来修饰方法，使其成为一个异步方法。例如：`async Task MyMethod() { ... }` 2. 调用异步方法：在需要调用异步方法的地方，使用`await`关键字来等待异步方法的完成。例如：`await MyMethod();` 3. 处理异步结果：异步方法可以返回一个`Task`对象或带有返回值的`Task<T>`对象。通过使用`await`关键字，可以获取异步方法的返回结果。 4. 异步异常处理：使用`try-catch`块来捕获异步方法中可能抛出的异常。 Async/await模型简化了异步编程的复杂性，使得代码更易读、维护和调试。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值