【并发编程】java多线程 未捕获异常 分析与处理【全网孤本】 持续更新补全中

置顶 已于 2023-09-06 02:21:55 修改
阅读量564 收藏
点赞数 2
分类专栏： 7788 并发编程 文章标签： java 开发语言 经验分享
于 2023-09-02 19:53:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43275385/article/details/132637291
版权

文章目录

全网孤本可能是在吹🍇… 争取全网最全

下次更新可能单独开篇

  • UncaughtExceptionHandler 原理分析
  • CompletableFuture 异常处理

本文主要整理了工作中常见的 线程异常处理方法，涵盖了对于手动创建的线程执行任务与线程池执行任务的异常处理等，除此之外还有关于FutureTask、CompletableFuture等执行时的异常处理的问题分析。

Thread提供的 未捕获异常处理

UncaughtExceptionHandler 分析

线程未捕获异常处理流程图

在这里插入图片描述

java多线程异常处理的流程图

源码分析

在这里插入图片描述
…

在这里插入图片描述
这里源码说起来就有点多了 TODO …

方式一：Thread 对象的 setUncaughtExceptionHandler

    public static void test01() {
        Thread ttt = new Thread(() -> {
            ThreadUtils.sleepSec(3);
            int a = 10 / 0;
            System.out.println("a = " + a);
        }, "TTT");

        ttt.setUncaughtExceptionHandler((t, e) -> {
            System.out.println("[t:" + t + "]" + "\n[e:" + e + "]");
        });

        ttt.start();
    }

执行结果

[TTT] INFO com.chengnanwuyin.thread_exception.ExceptionTest_01 - 
===== Thread:TTT-e:java.lang.ArithmeticException: / by zero =====

方式二：重写ThreadGroup的uncaughtException

与方法一本质相同

    private static void test02() {
        ThreadGroup threadGroup = new ThreadGroup("G-1") {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                log.error("\n===== [测试线程内异常抓取-group-uncaught] ERROR-Thread:{}-e:{} =====",
                        t.getName(), e.getMessage());
            }
        };

        Thread ttt02 = new Thread(threadGroup, () -> {
            ThreadUtils.sleepSec(1);
            int a = 10 / 0;
        }, "TTT-02");

        ttt02.start();
    }

执行结果

[TTT-02] ERROR com.chengnanwuyin.thread_exception.ExceptionTest_02_Group - 
===== [测试线程内异常抓取-group-uncaught] ERROR-Thread:TTT-02-e:/ by zero =====

方法三：设置默认的异常处理器

实现方式

  • 继承 Thread.UncaughtExceptionHandler
  • 重写 uncaughtException方法
    注意事项
  • 这里是为Thread设置其生命周期内的默认异常处理器，对某一个线程使用setUncaughtExceptionHandler 设置的异常处理，优先级高于默认异常处理。
/**
 * @author SurfingMaster
 * @date 2023/6/12
 */
public class ExceptionTest {
    private static final Logger log = LoggerFactory.getLogger(ExceptionTest_03.class);

    public static void main(String[] args) {

        Thread.setDefaultUncaughtExceptionHandler(new DefaultExceptionHandler());

        Thread ttt01 = new Thread(() -> {
            int a = 10 / 0;
        }, "TTT-01");

        ttt01.setUncaughtExceptionHandler((t, e) -> {
            log.error("\n===== [测试线程内异常抓取-setUncaughtExceptionHandler] Thread:{}-e:{} =====", currentThread().getName(), e.getMessage());
        });


        Thread ttt02 = new Thread(() -> {
            Integer[] integers = new Integer[-1];
        }, "TTT-02");

        ttt01.start();
        ttt02.start();

    }


    /**
     * 自定义异常处理：
     * 继承 Thread.UncaughtExceptionHandler <br>
     * 重写 uncaughtException方法 <br>
     */
    public static class DefaultExceptionHandler implements Thread.UncaughtExceptionHandler {
        @Override
        public void uncaughtException(Thread t, Throwable e) {
            log.error("\n===== [测试线程内异常抓取-DefaultExceptionHandler-uncaughtException] DefaultExceptionHandler-Thread:{}-e:{} =====",
                    currentThread().getName(), e.getMessage());
        }
    }
}

执行结果

 [TTT-02] ERROR com.chengnanwuyin.thread_exception.ExceptionTest_03 - 
===== [测试线程内异常抓取-DefaultExceptionHandler-uncaughtException] DefaultExceptionHandler-Thread:TTT-02-e:null =====
 [TTT-01] ERROR com.chengnanwuyin.thread_exception.ExceptionTest_03 - 
===== [测试线程内异常抓取-setUncaughtExceptionHandler] Thread:TTT-01-e:/ by zero =====

线程池的异常处理

  • 利用 UncaughtExceptionHandler 处理 线程池的异常和处理手动创建线程的异常在本质上一样的
  • 利用线程池的方法处理(例如afterExecute)，这里和UncaughtExceptionHandler的本质就有了区别。

方法一：线程内异常处理

并无特点，线程内的异常 线程内处理。

    public static void case01_try_catch() {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 2000, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadPoolExecutor.AbortPolicy());

        AtomicReference<Thread> thAtomicRef = new AtomicReference<Thread>();

        executor.execute(() -> {
            try {
                Thread value = currentThread();
                thAtomicRef.set(value);
                System.out.println(4 / 0);
            } catch (Exception e) {
                //log.error("\n===== 线程内部 ERROR-Thread:{}-e:{} =====", JSONObject.toJSONString(currentThread()), e.getMessage());
                log.error("\n===== 线程内部 ERROR-Thread:{}-e:{} =====", currentThread().getName() + currentThread().getState(), e.getMessage());
            }
        });

        ThreadUtils.sleepSec(1);
        log.info("\n===== Thread:{}-state:{} =====", thAtomicRef.get().getName(), thAtomicRef.get().getState());
    }

执行结果

 [pool-1-thread-1] ERROR com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== 线程内部 ERROR-Thread:pool-1-thread-1RUNNABLE-e:/ by zero =====
 [main] INFO com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== Thread:pool-1-thread-1-state:WAITING =====

执行分析

🧐，扒开看看其中线程池中的对象，最值得关注的是 UncaughtExceptionHandler
在这里插入图片描述
在这里插入图片描述
如果能给这里的UncaughtExceptionHandler赋值，那么异常处理会更加游刃有余。

方法二：自定义ThreadFactory，指定给线程池

基于线程池创建的对象的原理，关键是要清楚线程池对象的线程哪里来的。观察上一个方法的线程对象，自然有了此方法。

	/**
     * 
     * 继承实现ThreadFactory <br>
     * 重写 setUncaughtExceptionHandler
     * @param
     * @return void
     * @author SurfingMaster
     */
    private static void case_factoryUncaughtException() {
        AtomicReference<Thread> thAtomicRef = new AtomicReference<Thread>();

        ThreadPoolExecutor thPoolExe = new ThreadPoolExecutor(1, 2, 30, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r);
                        thread.setName("special-Thread-");
                        thread.setUncaughtExceptionHandler((Thread t, Throwable e) -> {
                            log.error("\n===== Thread:{}-t:{}-e:{} =====", currentThread().getName(), JSONObject.toJSONString(t), e);
                        });
                        return thread;
                    }
                },
                new ThreadPoolExecutor.AbortPolicy());

        thPoolExe.execute(() -> {
            thAtomicRef.set(currentThread());
            log.info("\n===== Thread:{} =====", currentThread().getName());
            int a = 10 / 0;
        });

        ThreadUtils.sleepSec(5);

        log.info("\n===== ExceptionTest_05_execute.main-thread.getState():{} =====", thAtomicRef.get().getState());
    }
  • 这个方法对应于 手动创建线程的异常处理 的方法一：单独为线程设置 setUncaughtExceptionHandler

执行结果

 [special-Thread-] INFO com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== Thread:special-Thread- =====
 [special-Thread-] ERROR com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== Thread:special-Thread--t:RUNNABLE-e:/ by zero =====

执行分析

创建线程池的时候，使用了自定义的线程工厂：
在这里插入图片描述
线程池执行任务时，线程的异常处理对象是创建时的对象
在这里插入图片描述
既然都 debug 到这里了，看看线程池执行的时候，怎么调用的异常处理方法。
在这里插入图片描述
debug追踪到这里，面对afterExecute，显然有了重写afterExecute的冲动。

方法三：重写 ThreadGroup的 异常处理函数

这个方法对应于，处理手动创建线程异常的方法二。

    /**
     * 重写 ThreadGroup的 异常处理函数
     *
     * @author SurfingMaster
     */
    private static void case_threadFactoryGroup() {
    
        AtomicReference<Thread> thAtomicRef = new AtomicReference<Thread>();

        ThreadPoolExecutor thExe = new ThreadPoolExecutor(1, 2, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(new TTT_ThreadGroup("G1"), r);
                thread.setName("G1-T-");
                return thread;
            }
        }, new ThreadPoolExecutor.AbortPolicy());

        thExe.execute(() -> {
            Thread curTh = currentThread();
            thAtomicRef.set(curTh);
            log.info("\n===== Thread:{} =====", currentThread().getName());
            int a = 10 / 0;
        });

        ThreadUtils.sleepSec(5);

        log.info("\n===== ExceptionTest_05_execute.main-thread.getState():{} =====", thAtomicRef.get().getState());

    }
	/**
     * 继承ThreadGroup <br>
     * 重写uncaughtException
     */
    public static class TTT_ThreadGroup extends ThreadGroup {
        public TTT_ThreadGroup(String name) {
            super(name);
        }

		// 这里也可以为当前组指定 上级
        public TTT_ThreadGroup(ThreadGroup parent, String name) {
            super(parent, name);
        }

        @Override
        public void uncaughtException(Thread t, Throwable e) {
            super.uncaughtException(t, e);
            log.info("\n===== Thread:{}-t:{}-e:{} =====", currentThread().getName(), t, e);
        }
    }

执行结果

 [G1-T-] INFO com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== Thread:G1-T- =====
 [G1-T-] INFO com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== Thread:G1-T--t:G1-T-RUNNABLE-e:{} =====
java.lang.ArithmeticException: / by zero
	at com.chengnanwuyin.thread_exception.ExceptionTest_05_execute.lambda$case_threadFactoryGroup$0(ExceptionTest_05_execute.java:71)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:750)
Exception in thread "G1-T-" java.lang.ArithmeticException: / by zero
	at com.chengnanwuyin.thread_exception.ExceptionTest_05_execute.lambda$case_threadFactoryGroup$0(ExceptionTest_05_execute.java:71)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:750)
 [main] INFO com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== ExceptionTest_05_execute.main-thread.getState():TERMINATED =====

这里的执行过程与上一个方法本质相同。

方法五： 重写 afterExecute 方法

这个方法其实是比较常用的方法了。
先看一眼大神Doug Lea 给的源码和注释。
在这里插入图片描述

  • 其中值得注意的是关于Runnable的描述：the runnable that has completed。也就是说，这里任务已经执行结束了。这里相当于是异步的

这里在创建 ThreadPoolExecutor对象的时候直接重写，也可以为某一类任务定义子类。当然生产上这里是要规范地写在配置类里。

    /**
     * 继承  ThreadPoolExecutor 重写 afterExecute 方法 <br>
     *
     * @author SurfingMaster
     */
    public static void case_afterExecute() {
        AtomicReference<Thread> thAtomicRef = new AtomicReference<Thread>();

        ThreadPoolExecutor thPoolExe = new ThreadPoolExecutor(1, 2, 30, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadPoolExecutor.AbortPolicy()) {
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                super.afterExecute(r, t);
                log.error("\n===== 执行异常 ERROR-r:{}-t:{} =====", JSONObject.toJSONString(r), t.getMessage());
            }
        };

        thPoolExe.execute(() -> {
            thAtomicRef.set(currentThread());
            log.info("\n===== Thread:{} =====", currentThread().getName());
            int a = 10 / 0;
        });
        ThreadUtils.sleepSec(1);

        log.info("\n===== thread.getState():{} =====", thAtomicRef.get().getState());

    }

执行结果

 [pool-1-thread-1] INFO com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== Thread:pool-1-thread-1 =====
 [pool-1-thread-1] ERROR com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== 执行异常 ERROR-r:{}-t:/ by zero =====
Exception in thread "pool-1-thread-1" java.lang.ArithmeticException: / by zero
	at com.chengnanwuyin.thread_exception.ExceptionTest_05_execute.lambda$case_afterExecute$2(ExceptionTest_05_execute.java:190)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:750)
 [main] INFO com.chengnanwuyin.thread_exception.ExceptionTest_05_execute - 
===== thread.getState():TERMINATED =====

执行分析

在这里插入图片描述
观察线程与任务的标识。
在这里插入图片描述

这里调用 afterExecute 方法传入的 Runnable 本质 仍为 其实现(Thread)的对象，并且标识与上一步的一致。
在这里插入图片描述

方法六：

这不算什么方法，就是针对 Future这种任务get方法的异常处理。

    /**
     * @author SurfingMaster
     */
    public static void case_futrue() {
        AtomicReference<Thread> thRef = new AtomicReference<>();

        ThreadPoolExecutor thExe = new ThreadPoolExecutor(2, 3, 3, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(),
                new ThreadPoolExecutor.AbortPolicy());

        Future<Integer> future = thExe.submit(() -> {
            thRef.set(currentThread());
            int a = 10 / 0;
            return a;
        });

        Integer res = null;
        try {
            res = future.get();
        } catch (InterruptedException | ExecutionException e) {
            log.error("\n===== [线程池执行submit-get处理异常] ERROR-e:{} =====", e.getMessage());
        }

        log.info("\n===== [线程池执行submit-get处理异常] -res:{}-COMPLETED. =====", res);

        log.info("\n===== Thread:{}-thRef:{} =====", JSONObject.toJSONString(thRef.get()), thRef);

    }

执行结果

 [main] ERROR com.chengnanwuyin.thread_exception.ExceptionTest_06_submit - 
===== [线程池执行submit-get处理异常] ERROR-e:java.lang.ArithmeticException: / by zero =====
 [main] INFO com.chengnanwuyin.thread_exception.ExceptionTest_06_submit - 
===== [线程池执行submit-get处理异常] -res:null-COMPLETED. =====

番外篇

对以上方法的补充

特殊关注一下FutureTask的方法

像方法五直接使用 afterExecute 方法，是抓取不到异常的；显然，FutureTask 任务，使用 setUncaughtExceptionHandler 也不会起作用。

这里大哥李的注释已经说的非常清楚了。在这里插入图片描述

简而言之，线程池对象执行 task.run() 时，它自己维护执行的异常，task.run调用时，捕获不到FutureTask的异常，所以需要"further probe"：通过get方法显式调用然后抓取😏。

但是这样和在外部获取get时处理异常好像并没有什么优势。emmm，除了使用了FutureTask但不调用get…如果没有这个兜底，异常可能就丢了。

这里是执行分析图：

【并发编程】FutureTask 执行 / 异常捕获 分析图

先上代码，再分析。

    /**
     * @author SurfingMaster
     */
    public static void case_futrue() {
        AtomicReference<Thread> thRef = new AtomicReference<>();

        ThreadPoolExecutor thExe = new ThreadPoolExecutor(2, 3, 3, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(),
                new ThreadPoolExecutor.AbortPolicy()) {

            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                super.afterExecute(r, t);

                if (t == null && r instanceof Future<?>) {
                    try {
                        Object result = ((Future<?>) r).get();  //
                    } catch (CancellationException ce) {
                        t = ce;
                    } catch (ExecutionException ee) {
                        t = ee.getCause();
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt(); // ignore/reset
                    }
                }
                if (t != null) {
                    log.error("\n===== 执行异常-afterExecute处理-r:{}-t:{} =====", JSONObject.toJSONString(r), t.getMessage());
                }
            }
        };

        Future<Integer> future = thExe.submit(() -> {
            thRef.set(currentThread());
            int a = 10 / 0;
            return a;
        });

        Integer res = null;
        try {
            ThreadUtils.sleepSec(1);
            res = future.get();
        } catch (InterruptedException | ExecutionException e) {
            log.error("\n===== [线程池执行submit-外部get处理异常] ERROR-e:{} =====", e.getMessage());
        }

        //log.info("\n===== Thread:{}-thRef:{} =====", JSONObject.toJSONString(thRef.get()), thRef);

    }

执行结果

 [pool-1-thread-1] ERROR com.chengnanwuyin.thread_exception.ExceptionTest_06_submit - 
===== 执行异常-afterExecute处理-r:{"cancelled":false,"done":true}-t:/ by zero =====
 [main] ERROR com.chengnanwuyin.thread_exception.ExceptionTest_06_submit - 
===== [线程池执行submit-外部get处理异常] ERROR-e:java.lang.ArithmeticException: / by zero =====

执行分析

在这里插入图片描述
至于捕获不到的原因，就得聊 FutureTask 的执行：

  • 先用一句话概括：遇到异常时 try-catch 了异常，并且保存了下来，在get时才会抛出。
  • FutureTask 封装的比较严密，其返回值存储在 outcome 中，嗯大哥李很骚，用 state、stateOffset 来标记 outcome 的类型，最后在get中调用report方法。

【并发编程】FutureTask 执行 / 异常捕获 分析图

CompletableFuture 异常处理

TODO…

SurfingMaster
关注
专栏目录
Java-捕获线程异常可以有哪些方式实现
兴趣是最好的老师
08-14 213
如果使用ExecutorService执行任务，并且任务实现了Callable接口，那么可以通过Future.get()方法。如果任务抛出了异常，Future.get()会重新抛出这个异常，从而可以在调用线程中捕获它。每个线程都可以设置一个未捕获异常处理器，当线程中抛出未捕获的异常时，这个处理器就会被调。子线程可以在抛出异常时将异常放入共享变量或队列中，主线程可以轮询或等待这些结构中的异常。选择哪种方法取决于你的具体需求和你正在使用的并发模式。在许多情况下，将异常记录到日志中是最简单和最实用的方法。
三十年了，读书依然不求甚解：一个普通程序员的读书生涯回顾
AI天才研究院
04-23 9381
三十年了，读书依然不求甚解：一个普通程序员的读书生涯回顾藏书人的圣地《查令十字街84号》今日仅存的铭牌。今天是世界读书日，我一般很少关注这种形式化的节日。最近在修年假，将近一个月的时间，可...
异常没有被捕获
qq_42278023的博客
07-20 794
今天线上产生了一个异常报错java.lang.reflect.InvocationTargetException，但是非常奇怪的是其正直原因是因为包冲突，找不到类方法导致（java.lang.NoSuchMethodError），而且异常是在最外层才被捕获，产生异常方法中和它更上层调用的方法中都有加异常捕获。在这个问题上卡了挺久，一直想不通其中原因，最后看到了NoSuchMethodError中的...
用Thread中的UncaughtExceptionHandler来处理未捕获的异常
最新发布
YIYIYI
08-24 954
用Thread中的UncaughtExceptionHandler来处理未捕获的异常
Java 线程中的未捕获异常处理
“罐装面包”的博客
05-04 1654
由于线程的本质特性，使得不能捕获从线程中逃逸的异常。一旦异常逃逸出任务的 run() 方法，它就会向外传播到控制台，除非采取特殊的步骤捕获这种错误的异常。 下面的任务总是会抛出一个异常： public class Main{ public static void main(String[] args) { ExecutorService exec = Executors.newCa...
线程池用execute抛出异常 捕获不到
qq_38030465的博客
05-22 359
我们可以用submit,submit方法会返回Future对象，Future.get()方法会把异常抛出来。这里使用execute可以看到抛出异常的是try里的，没有进入到catch里。
java 无法捕获异常_java中是不是在方法声明中抛出了异常就无法在方法体捕捉异常？...
weixin_26706567的博客
02-16 200
//举例说明public class Test {public static void main(String[] args) {int id=1;while(id<5){try {switch(id) {case 1:f1();break;case 2:f2();break;case 3:f3();break;case 4:f4();break;}}catch(MyException e)...
一个程序员的日常书单(更新于2018/10/7)
Floating Cat
02-11 2万+
今日元宵节,祝各位节日快乐.本想谈谈读书这个话题,想来想起觉得无从下手,就此作罢.毕业这几年,一直不敢放松,在现代这个互联网时代更加认同萧抡谓的”一日不读书,胸臆无佳想;一月不读书,耳目失清爽”.如果非要给自己找个读书的理由的话,这句诗就是最好的理由:”胸藏文墨虚若骨,腹有诗书气自华”.
Panda白话 - 再认识JAVA反射
FightingITPanda的博客
05-19 271
最近学习路线：AOP原理 -> JDK 动态代理 -> java 反射 真是人生无常，大肠包小肠呀～～ 反射 定义：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 这个定义看了n遍，每次都是？？？（小朋友你是否有很多问号？） 最近又看了书、文章、视频，有了新的理解，码下来。。万一对你有用 知识储备（面试高频）： 类加载机制 j.
AI能让杨超越跳舞？背后原理大揭秘！
热门推荐
Python爱好者的专栏
04-05 2万+
上个月杨超越编程大赛在github上大火了一段时间，不过随着时间失衡其热度慢慢下降了，不过而该赛事的31号作品《YCY Dance Now》横空出世，能够做到让用户给定一段跳舞的源视频并上传到指定网站，然后就可以欣赏到杨超越（注意这里不是单纯的换脸，而是整个人连同装束全变），表演这套舞蹈动作的视频了。由于笔者并没有得到杨超越的任何授权，为避免纠纷这里就以另一个效果类似的动态图向大家展示...
高校图书馆信息化发展中存在的问题及应对措施.docx
03-12
然而，在实际发展过程中，高校图书馆信息化面临着一系列挑战和问题。 首先，图书管理信息化的重视程度不足。部分高校对图书馆信息化的理解停留在表面，仅将其视为使用互联网和电脑的简单工具，忽视了信息化对提升...
Java并发（八）--线程未捕获异常处理详解
qq_40089907的博客
04-08 506
文章目录1. 为什么需要UncaughtExceptionHandler?2. 两种解决方案 1. 为什么需要UncaughtExceptionHandler? 1.主线程可以轻松发现异常，而子线程不可以。 /** * @author zhoup * @date 2020/4/7 14:15 * @describe */ public class ExceptionChildThread ...
java-未捕获异常的处理_java多线程的未捕获异常处理机制
weixin_34138673的博客
02-25 475
一：为什么要单独讲多线程的异常捕捉呢？先看个例子：public class ThreadException implements Runnable{@Overridepublic void run() {throw new RuntimeException();}//现象：控制台打印出异常信息，并运行一段时间后才停止public static void main(String[] args){//...
java-未捕获异常的处理,Java未捕获全局异常处理程序
weixin_42627459的博客
02-19 192
I have an application and need to code a custom global uncaught exception handler. I've read all the stackoverflow threads and each one of them is just missing a clear and simple example of how this i...
线程池抛出异常 捕获不到怎么办
郎涯技术
04-28 1337
https://mp.weixin.qq.com/s/VfReAqovJwmn5IoadC_7ug，郎涯进行简单排版与补充在实际开发中，我们常常会用到线程池，但任务一旦提交到线程池之后，如果发生异常之后，怎么处理？怎么获取到异常信息？在了解这个问题之前，可以先看一下 线程池的源码解析，从源码中我们知道了线程池的提交方式：submit 和execute 的区别，接下来分别使用他们执行带有异常的任务！看结果是怎么样的！运行结果：可以看到：submit 不打印异常信息，而 execute 则会打印异常信息。
Java线程池的异常捕获方式
qq_45743985的博客
08-29 749
Java线程池的异常捕获方式
线程池使用时，注意异常的捕获
xinxin199209的博客
10-17 362
代码注意事项
java-未捕获异常的处理
深未来技术
02-21 192
当一个线程因为未捕获异常而退出时，JVM会把这个事件报告给应用程序提供的UncaughtExceptionHandler, 如果handler不存在，默认的行为是向System.err打印出栈追踪信息。 public interface UncaughtExceptionHandler{     void uncaughtException(Thread t,Throwable e);}...
【Java线程】线程池的拒绝策略、异常捕获
qq_43783527的博客
05-30 4100
目录标题拒绝策略1、拒绝策略使用场景2、JDK内置拒绝策略3、自定义线程池创建方式4、自定义拒绝策略1.简单示例2.JAVA线程池自定义拒绝策略以及利用反射获取任务参数线程池异常处理1、run函数中的try catch是必须的2、其他异常捕获1.通过设置UncaughtExceptionHandler打印异常日志2.双层try catch嵌套（项目中的使用） 使用线程池之前，先思考下面几个问题： 该异步场景适合用线程还是线程池？ 使用JAVA默认的线程池，还是自定义的线程池？ 使用JAVA默认的拒绝策略，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值