Java多线程：捕获线程异常

最新推荐文章于 2022-10-10 16:52:40 发布
最新推荐文章于 2022-10-10 16:52:40 发布
阅读量238 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/futao__/article/details/107194761
版权

你处理过多线程中的异常吗？如何捕获多线程中发生的异常？捕获子线程的异常与捕获当前线程的异常一样简单吗？

除了try catch。Java中还可以通过异常处理器UncaughtExceptionHandler来处理那些未捕获的异常。

# 在当前线程捕获当前线程发生的异常:
/**
 * @author futao
 * @date 2020/6/17
 */
@Slf4j
public class ExceptionInCurThread {
    public static void main(String[] args) {
        try {
            throw new RuntimeException("在主线程抛出异常，在主线程捕获");
        } catch (RuntimeException e) {
            log.error("捕获到异常", e);
        }
    }
}

  • 结果:

image.png

  • 结论：在当前线程通过try catch可以捕获当前线程抛出的异常。

# 可以在当前通过try catch的方式捕获其他线程抛出的异常吗?'
/**
 * @author 喜欢天文的pony站长
 * Created on 2020/6/16.
 */
public class ExceptionInChildThread implements Runnable {

    @Override
    public void run() {
        throw new RuntimeException("子线程发生了异常...");
    }

    /**
     * 模拟子线程发生异常
     *
     * @throws InterruptedException
     */
    private static void exceptionThread() throws InterruptedException {
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
    }

    /**
     * 在主线程尝试通过try catch捕获异常
     */
    private static void catchInMain() {
        try {
            exceptionThread();
        } catch (Exception e) {
            //无法捕获发生在其他线程中的异常
            log.error("捕获到了异常?", e);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExceptionInChildThread.catchInMain();
    }

}

  • (错误的)预期:

    • 在运行第一个线程的时候发生了异常，被catch捕获，打印捕获到了异常?和异常堆栈且后面的线程将不会运行。

  • 实际运行结果:

    • 并不符合预期。

    • 没有被try catch捕获。

    • 后续的线程没有因为第一个线程发生异常而跳过。

image.png

  • 结论:

    • 无法在一个线程中通过try catch捕获另外一个线程的异常。

# 解决方案

  1. 在每个线程内部run()方法内通过try catch捕获当前线程发生的异常。

  • 缺点：每个线程都需要编写重复的try catch 代码

  • 使用线程异常处理器UncaughtExceptionHandler

    • 给所有线程设置统一的异常处理器

    • 给每个线程设置特定的异常处理器

    • 给线程组设置异常处理器

    • 给线程池设置异常处理器

      • 因为线程池也是通过new Thread()的方式创建的线程，所以思想与上面两种方法一致。

      • 注意：execute()与submit()方式对    异常处理的不同。

    # 在线程内部run()通过try catch捕获异常
    /**
 * @author 喜欢天文的pony站长
 * Created on 2020/6/16.
 */
@Slf4j
public class ExceptionInChildThread implements Runnable {

    @Override
    public void run() {
        try {
            //do something else...
            throw new RuntimeException("子线程发生了异常...");
        } catch (Exception e) {
            log.error("在线程内部捕获异常", e);
        }
    }

    /**
     * 模拟子线程发生异常
     *
     * @throws InterruptedException
     */
    private static void exceptionThread() throws InterruptedException {
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
    }

    /**
     * 在主线程尝试通过try catch捕获异常
     */
    private static void catchInMain() {
        try {
            exceptionThread();
        } catch (Exception e) {
            //无法捕获发生在其他线程中的异常
            log.error("捕获到了异常?", e);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExceptionInChildThread.catchInMain();
    }
}

    • 结果:

      • 成功在子线程内部run()方法捕获到了异常

    image.png
    # 使用线程异常处理器UncaughtExceptionHandler

    当一个线程由于未捕获异常而退出时，JVM会把这个事件报告给应用程序提供的UncaughtExceptionHandler异常处理器

    • 自定义线程异常处理器

    /**
 * 自定义线程未捕获异常处理器
 *
 * @author futao
 * @date 2020/6/17
 */
public class CustomThreadUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {

    private static final Logger LOGGER = LoggerFactory.getLogger(CustomThreadUncaughtExceptionHandler.class);

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        LOGGER.error("捕获到线程发生的异常，线程信息:[{}]", JSON.toJSONString(t), e);
    }
}

    • 使用:

    1. 全局:

    • Thread.setDefaultUncaughtExceptionHandler(new CustomThreadUncaughtExceptionHandler());

      • 通过调用Thread的静态方法setDefaultUncaughtExceptionHandler()，设置Thread的静态属性defaultUncaughtExceptionHandler.为我们自定义的异常处理器。

      • 源码:

    • 测试:

    /**
 * @author 喜欢天文的pony站长
 * Created on 2020/6/16.
 */
@Slf4j
public class ExceptionInChildThread implements Runnable {

    @Override
    public void run() {
        throw new RuntimeException("子线程发生了异常...");
    }

    /**
     * 模拟子线程发生异常
     *
     * @throws InterruptedException
     */
    private static void exceptionThread() throws InterruptedException {
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
    }

    public static void main(String[] args) throws InterruptedException {
        //设置全局的线程异常处理器
        Thread.setDefaultUncaughtExceptionHandler(new CustomThreadUncaughtExceptionHandler());
        exceptionThread();
    }
}

    • 结果: 成功捕获

    image.png
    2. 为指定线程设置特定的异常处理器

    • 细心的同学已经发现了，在上面Thread类的截图中，还有一个实例属性private volatile UncaughtExceptionHandler uncaughtExceptionHandler;。通过给这个属性赋值，可以实现为每个线程对象设置不同的异常处理器。

    • 测试使用

    /**
 * @author 喜欢天文的pony站长
 * Created on 2020/6/16.
 */
@Slf4j
public class ExceptionInChildThread implements Runnable {

    @Override
    public void run() {
        throw new RuntimeException("子线程发生了异常...");
    }

    /**
     * 模拟子线程发生异常
     *
     * @throws InterruptedException
     */
    private static void exceptionThread() throws InterruptedException {
        Thread thread1 = new Thread(new ExceptionInChildThread());
        //为指定线程设置特定的异常处理器
        thread1.setUncaughtExceptionHandler(new CustomThreadUncaughtExceptionHandler());
        thread1.start();
        TimeUnit.MILLISECONDS.sleep(200L);

        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);

        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);

        new Thread(new ExceptionInChildThread()).start();
        TimeUnit.MILLISECONDS.sleep(200L);
    }

    public static void main(String[] args) throws InterruptedException {
        exceptionThread();
    }
}

    • 结果: 成功捕获线程1的异常信息

    3. 线程组
    /**
 * @author futao
 * @date 2020/6/20
 */
@Slf4j
public class ExceptionInThreadGroup implements Runnable {

    @Override
    public void run() {
        throw new RuntimeException("线程任务发生了异常");
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadGroup threadGroup = new ThreadGroup("只知道抛出异常的线程组...") {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                super.uncaughtException(t, e);
                log.error("线程组内捕获到线程[{},{}]异常", t.getId(), t.getName(), e);
            }
        };
        ExceptionInThreadGroup exceptionInThreadGroup = new ExceptionInThreadGroup();

        new Thread(threadGroup, exceptionInThreadGroup, "线程1").start();
        TimeUnit.MILLISECONDS.sleep(300L);

        //优先获取绑定在thread对象上的异常处理器
        Thread thread = new Thread(threadGroup, exceptionInThreadGroup, "线程2");
        thread.setUncaughtExceptionHandler(new CustomThreadUncaughtExceptionHandler());
        thread.start();
        TimeUnit.MILLISECONDS.sleep(300L);

        new Thread(threadGroup, exceptionInThreadGroup, "线程3").start();
    }
}

    • 结果:

    4. 线程池
    /**
 * @author futao
 * @date 2020/6/17
 */
public class CatchThreadPoolException {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,
                4,
                1L,
                TimeUnit.MINUTES,
                new LinkedBlockingDeque<>(1024),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r);
                        //设置线程异常处理器
                        thread.setUncaughtExceptionHandler(new CustomThreadUncaughtExceptionHandler());
                        return thread;
                    }
                }
        );

        threadPoolExecutor.execute(new Runnable() {
                                       @Override
                                       public void run() {
                                           throw new RuntimeException("execute()发生异常");
                                       }
                                   }
        );

        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                throw new RuntimeException("submit.run()发生异常");
            }
        });

        threadPoolExecutor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                throw new RuntimeException("submit.call()发生异常");
            }
        });
      threadPoolExecutor.shutdown();
    }
}

    • 结果: 并不符合预期，预期应该捕获三个异常

      • 只捕获到了通过execute()提交的任务的异常

      • 没有捕获到通过submit()提交的任务的异常

    • 通过afterExecute()捕获submit()任务的异常

      • 通过submit()方法的源码可以发现，submit()是将runnable()封装成了RunnableFuture<Void>，并最终调用execute(ftask);执行。

    
/**
 * @author futao
 * @date 2020/6/17
 */
@Slf4j
public class CatchThreadPoolException {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,
                4,
                1L,
                TimeUnit.MINUTES,
                new LinkedBlockingDeque<>(1024),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r);
                        //设置线程异常处理器
                        thread.setUncaughtExceptionHandler(new CustomThreadUncaughtExceptionHandler());
                        return thread;
                    }
                }
        ) {
            /**
             * 捕获{@code FutureTask<?>}抛出的异常
             *
             * @param r
             * @param t
             */
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                super.afterExecute(r, t);
                if (r instanceof FutureTask<?>) {
                    try {
                        //get()的时候会将异常内的异常抛出
                        ((FutureTask<?>) r).get();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    } catch (ExecutionException e) {
                        log.error("捕获到线程的异常返回值", e);
                    }
                }
                //Throwable t永远为null，拿不到异常信息
                //log.error("afterExecute中捕获到异常，", t);
            }
        };

        threadPoolExecutor.execute(new Runnable() {
           @Override
           public void run() {
               throw new RuntimeException("execute()发生异常");
           }
       }
        );
        TimeUnit.MILLISECONDS.sleep(200L);

        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                throw new RuntimeException("submit.run()发生异常");
            }
        });
        TimeUnit.MILLISECONDS.sleep(200L);

        threadPoolExecutor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                throw new RuntimeException("submit.call()发生异常");
            }
        }).get();   //get()的时候会将异常抛出

        threadPoolExecutor.shutdown();
    }
}

    欢迎在评论区留下你看文章时的思考，及时说出，有助于加深记忆和理解，还能和像你一样也喜欢这个话题的读者相遇~

    # 本文源代码

    • https://github.com/FutaoSmile/learn-thread/tree/master/src/main/java/com/futao/learn/threads/捕获线程异常

    # 系列文章

Niubist_
关注
多线程编程注意捕获异常
bin的主栏
03-09 292
多线程编程时，注意每个线程处理的任务是否存在异常的情况，如果存在，必须try catch进行捕获，否则只要一个线程出现异常，就会阻塞后面的线程的执行。      工资代发业务时，通过rabbitMQ消息队列的方式和其他系统进行交互，在对发过来的消息进行校验员工数据，其中一条数据出现了异常，导致后面的消息一只阻塞在队列中，无法消费。例如下面的例子：参考：https://my.oschin...
java 多线程之异常
qq_40945282的博客
10-17 370
1.1异常概念 异常 ：指的是程序在执行过程中，出现的非正常情况，最终会导致jvm的非正常停止。 在java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出一个异常对象。java处理异常的方式是中断处理 中断机制：jvm中断程序，并在控制台打印异常 1.2异常的体系 异常机制其实就是帮助我们找到程序中的问题，异常的根类是 java . lang . Throwab...
Java多线程之多线程异常捕捉
09-03
在java多线程程序中，所有线程都不允许抛出未捕获的checked exception，也就是说各个线程需要自己把自己的checked exception处理掉，通过此篇文章给大家分享Java多线程之多线程异常捕捉，需要的朋友可以参考下
Java多线程——<七>多线程的异常捕捉
weixin_30376509的博客
08-12 400
一、概述 　　为什么要单独讲多线程的异常捕捉呢？先看个例子： public class ThreadException implements Runnable{ @Override public void run() { throw new RuntimeException(); } //现象：控制台打印出异常信息，并运行一段时间后...
多线程捕获运行时异常
最新发布
RichardPan0000的博客
10-10 803
java多线程捕获异常
JAVA-多线程-线程异常捕获
易水寒冰的博客
08-02 506
问题 上周五同事问我一个问题 ，在下发给下游数据的时候 ，其中的一条数据处理异常了，不影响其他数据继续处理 他处理的方式 AsynThreadExecutorSingleton.INSTANCE.execute(()-> { //TODO 业务处理 } catch(Exception e) { LOGGER.error("Exception e={}", e); }
详解Java中多线程异常捕获Runnable的实现
08-29
Java 多线程异常捕获 Runnable 实现详解 Java 多线程编程是一个非常重要的知识点，然而在多线程编程中，异常捕获是一个很大的挑战。本文主要介绍了 Java 中多线程异常捕获 Runnable 的实现，包括背景、工具、思路、...
java多线程编程之捕获子线程异常示例
09-04
总结起来，Java多线程编程中，处理子线程异常的关键在于利用`Thread.setUncaughtExceptionHandler`方法，为每个线程设置一个异常处理器，以便在发生未捕获异常时得到通知并进行适当的处理。这对于维护程序的稳定性...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程，对多线程，线程池进行封装，方便使用
05-16
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，我们可以通过实现Runnable接口或继承Thread类来创建线程。然而，直接使用线程可能存在一些问题，如资源管理...
java多线程异常捕获
a304096740的博客
06-26 99
java多线程中出现了异常，如何捕获。利用UncaughtExceptionHandler这个接口就可以了。 代码如下: package com.ming.thread.six.threadcreateException; public class MyThread extends Thread{ public void run(){ Str...
java多线程之捕获异常
独自登高楼 望断天涯路
08-11 2691
package com.eshroe.sweetop.concurrency;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.ThreadFactory;//产生异常class ExceptionThread
多线程的异常捕捉
中国华的博客
03-13 1341
一、概述 为什么要单独讲多线程的异常捕捉呢？先看个例子： public class ThreadException implements Runnable{ @Override public void run() { throw new RuntimeException(); } //现象：控制台打印出异常信息，并运行一段时间后才停止 pub...
捕捉线程的异常
czmchen的专栏
03-07 4474
线程的正常运行和销毁一般都是用java.util.concurrent.ExecutorService，这个接口能提供线程很多的帮助简单的线程异常捕捉示例public class TestThread implements Runnable{     public void run() {         throw new RuntimeException("throwing runtimeException.....");     } }当线程代码抛出运行级别异常之后，线程会中断。主线程不受这个
java线程池异常_Java多线程——<七>多线程的异常捕捉
weixin_33665771的博客
02-12 198
一、概述为什么要单独讲多线程的异常捕捉呢？先看个例子：publicclass ThreadException implements Runnable{@Overridepublicvoid run() {throw new RuntimeException();}//现象：控制台打印出异常信息，并运行一段时间后才停止public static void main(String[]args){//就...
如何捕获多线程异常
coder-zzzz的博客
04-24 2144
1.多线程常用方式 创建Thread 使用线程池 2.实现接口 Runnable，无返回值 Callable，可有返回值 3.异常捕获 线程运行过程中发生的异常，无法通过try catch方式，在外层进行捕获，例如 try { new Thread(new Runnable() { @Override p...
多线程之运行线程异常捕获
.
12-23 398
多线程之运行线程异常捕获 /** * @description: 线程异常捕捉 * @author: Administrator * @create: 2019-12-23 22:22 **/ public class ThreadException { public static void main(String[] args) { //线程抛出异常 ...
Java多线程之捕获异常
paullinjie的博客
12-13 471
1.主线程不能捕获到子线程的异常 package Thread.Exection; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ExeceptionThread implements Runnable { @Override
Java多线程：线程状态详解
"这篇资料是关于Java多线程的，主要介绍了线程的状态以及与进程的相关概念。" 在Java编程中，多线程是实现并发处理的重要手段，它允许程序中多个任务同时运行，提高CPU利用率。线程的状态主要包括Born、Runnable、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值