线程池的异常处理

最新推荐文章于 2024-05-17 17:04:28 发布
最新推荐文章于 2024-05-17 17:04:28 发布
阅读量550 收藏
点赞数
分类专栏： 并发编程专题 文章标签： java 并发编程 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43885975/article/details/118934058
版权

【并发编程】知识脉络 中学习和使用了ThreadPoolExecutor线程池

但是线程池中的线程执行任务时候出现异常怎么办？该如何处理？

目录

模拟任务中出现异常

第一种情况：对异常不做任何处理

任务类：

 测试类

测试结果：

第二种情况：throw抛出异常

任务类：

测试类

 测试结果

第三种情况：捕获异常

任务类

 测试类

测试结果

总结

为避免线程池停止工作，为避免异常被吞，请手动捕获处理异常！

模拟任务中出现异常

第一种情况：对异常不做任何处理

任务类：

/**
 * @Description : TODO 模拟任务执行过程中出现异常，且不做任何处理
 * @Author : lixiunan
 * @Date : 2021/7/20
 **/
@Slf4j
public class NoneTask implements Runnable{
    @Override
    public void run() {
        log.info("开始");
        //时间戳摩2会有机会==1进入
        if(System.currentTimeMillis() % 2 == 1){
            //制造异常阻断程序正常执行
            int i = 5/0;
            log.info("异常了");
        }else{
            log.info("正常");
        }
        log.info("结束");
    }
}

 测试类

/**
 * @Description : TODO 开启两个线程，每间隔5秒就重复执行一次任务
 * @Author : lixiunan
 * @Date : 2021/7/20
 **/
public class TestScheduleException {

    public static void main(String[] args) {
        final int CORE_SIZE = 2;
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor =
                new ScheduledThreadPoolExecutor(CORE_SIZE);
        for (int i = 0; i < CORE_SIZE; i++) {
            scheduledThreadPoolExecutor.scheduleWithFixedDelay(
                    new NoneTask(),1000,5000, TimeUnit.MILLISECONDS);
        }
    }

}

测试结果：

[pool-1-thread-1] INFO testException.NoneTask - 开始
[pool-1-thread-1] INFO testException.NoneTask - 正常
[pool-1-thread-1] INFO testException.NoneTask - 结束
[pool-1-thread-2] INFO testException.NoneTask - 开始
[pool-1-thread-2] INFO testException.NoneTask - 正常
[pool-1-thread-2] INFO testException.NoneTask - 结束
[pool-1-thread-1] INFO testException.NoneTask - 开始
[pool-1-thread-2] INFO testException.NoneTask - 开始

程序会卡住！并不结束！并不输出任何的信息！ 

第二种情况：throw抛出异常

任务类：

/**
 * @Description : TODO 假设>5秒就是异常情况，并抛出异常
 * @Author : lixiunan
 * @Date : 2021/7/20
 **/
@Slf4j
public class ThrowTask implements Runnable{
    @SneakyThrows
    @Override
    public void run() {
        log.info("开始");
        int time = random();
        if(time >= 5){//任务执行有异常 ： 并显式地去抛出异常
            throw new RuntimeException("任务执行超过五秒有异常");
        }else {//任务执行正常
            log.info("正常执行任务");
            Thread.sleep(time*1000);
        }
        log.info("结束");
    }

    /**
     * 随机生成1-10之间的数
     * @return
     */
    public int random(){
        Random rand = new Random();
        return rand.nextInt(10)+1;
    }
}

测试类

/**
 * @Description : TODO 开启两个线程，每间隔5秒就重复执行一次任务
 * @Author : lixiunan
 * @Date : 2021/7/20
 **/
public class TestScheduleException {

    public static void main(String[] args) {
        final int CORE_SIZE = 2;
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor =
                new ScheduledThreadPoolExecutor(CORE_SIZE);
        for (int i = 0; i < CORE_SIZE; i++) {
            scheduledThreadPoolExecutor.scheduleWithFixedDelay(
                    new ThrowTask(),1000,5000, TimeUnit.MILLISECONDS);
        }
    }

}

 测试结果

[pool-1-thread-2] INFO testException.ThrowTask - 开始
[pool-1-thread-1] INFO testException.ThrowTask - 开始
[pool-1-thread-1] INFO testException.ThrowTask - 正常执行任务
[pool-1-thread-1] INFO testException.ThrowTask - 结束
[pool-1-thread-1] INFO testException.ThrowTask - 开始

程序会卡住！并不结束！并不输出任何的信息！ 

第三种情况：捕获异常

任务类

/**
 * @Description : TODO 对执行的逻辑进行try包裹
 * @Author : lixiunan
 * @Date : 2021/7/20
 **/
@Slf4j
public class CatchTask implements Runnable{
    @SneakyThrows
    @Override
    public void run() {
        log.info("开始");
        try {
            if(System.currentTimeMillis() % 2 == 1){
                Thread.sleep(5000);
                throw new RuntimeException("模拟异常");
            }else{
                log.info("正常执行");
                Thread.sleep(1000);
            }

        }catch (RuntimeException e){
            log.info("捕获到模拟异常");
        }
        log.info("结束");
    }
}

 测试类

/**
 * @Description : TODO 开启两个线程，每间隔5秒就重复执行一次任务
 * @Author : lixiunan
 * @Date : 2021/7/20
 **/
public class TestScheduleException {

    public static void main(String[] args) {
        final int CORE_SIZE = 2;
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor =
                new ScheduledThreadPoolExecutor(CORE_SIZE);
        for (int i = 0; i < CORE_SIZE; i++) {
            scheduledThreadPoolExecutor.scheduleWithFixedDelay(
                    new CatchTask(),1000,5000, TimeUnit.MILLISECONDS);
        }
    }

}

测试结果

[pool-1-thread-1] INFO testException.CatchTask - 开始
[pool-1-thread-1] INFO testException.CatchTask - 正常执行
[pool-1-thread-2] INFO testException.CatchTask - 开始
[pool-1-thread-2] INFO testException.CatchTask - 正常执行
[pool-1-thread-1] INFO testException.CatchTask - 结束
[pool-1-thread-2] INFO testException.CatchTask - 结束
[pool-1-thread-1] INFO testException.CatchTask - 开始
[pool-1-thread-2] INFO testException.CatchTask - 开始
[pool-1-thread-1] INFO testException.CatchTask - 捕获到模拟异常
[pool-1-thread-1] INFO testException.CatchTask - 结束
[pool-1-thread-2] INFO testException.CatchTask - 捕获到模拟异常
[pool-1-thread-2] INFO testException.CatchTask - 结束
[pool-1-thread-1] INFO testException.CatchTask - 开始
[pool-1-thread-2] INFO testException.CatchTask - 开始
[pool-1-thread-2] INFO testException.CatchTask - 捕获到模拟异常
[pool-1-thread-2] INFO testException.CatchTask - 结束
[pool-1-thread-1] INFO testException.CatchTask - 捕获到模拟异常
[pool-1-thread-1] INFO testException.CatchTask - 结束
[pool-1-thread-2] INFO testException.CatchTask - 开始
[pool-1-thread-2] INFO testException.CatchTask - 正常执行
[pool-1-thread-1] INFO testException.CatchTask - 开始
[pool-1-thread-1] INFO testException.CatchTask - 正常执行
[pool-1-thread-1] INFO testException.CatchTask - 结束
[pool-1-thread-2] INFO testException.CatchTask - 结束

程序会一直正常执行！并输出有异常时的信息！  

总结

为避免线程池停止工作，为避免异常被吞，请手动捕获处理异常！

Java程序员调优
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线程异常处理
LZN的博客
05-06 1543
文章目录一、线程池异常处理流程二、源码执行流程2.1 execute 执行流程2.2 submit 执行流程三、线程异常捕获方法3.1 在 Runnable#run 方法中捕获代码异常3.2 在 Callable#call 方法中捕获异常3.3 重写 ThreadPoolExecutor#afterExecute3.4 为工作者线程设置 UncaughtExceptionHandler 一、线程池异常处理流程 1.1 当执行方式是 execute 时，可以看到堆栈异常的输出 原因：ThreadPoolExe
java多线程中的异常处理机制简析
09-05
Java多线程异常处理机制是Java并发编程中不可或缺的一部分，主要关注如何管理和处理在多线程环境下出现的异常。在Java中，异常分为两大类：Checked异常和Unchecked异常。Checked异常是那些在编译期间必须处理的异常...
线程池异常如何处理你都了解吗？
热门推荐
weixin_45987961的博客
02-04 1万+
大家在开发的过程中是否发现，我们使用线程池的时候很少去处理运行过程中出现的错误，不处理错误这样没关系吗？不处理会不会导致线程池结束？如果需要处理错误我们应该如何进行处理呢？那么今天从以下几个方面来看一下 1.线程池异常 通过代码来演示三种异常线程池的情况。 1.1Runable执行异常(业务异常) 测试代码： public class ThreadPoolExceptionTest { public static void main(String[] args) {
ThreadpoolExecutor处理task执行异常
weixin_45214524的博客
04-04 989
日常开发中使用线程池时，发现线程池里的任务异常中断/失败是不会打印错误信息的，导致结果异常还不知道发生什么。线程池提交作业后，worker不会主动抛出异常。需要通过future对象的。任务提交完后，得到future对象列表/字典。是否为空判断该任务是否有异常信息。遍历线程池中完成的task。线程的执行结果是否异常。遍历完成的task也就是。遍历完成的task也就是。方法提交任务后后返回。
线程池异常如何处理？
最新发布
lucky_love816的博客
05-17 1073
忽的一下，想到了线程池的比较重要的一个参数：ThreadFactory接口，这个接口的作用是按需创建新线程的，使用线程工厂消除了对Thread#Thread(Runnable) new Thread的强依赖，使应用程序能够使用特殊的Thread子类、优先级等。大白话就是让线程池中的线程使用我们自定义的线程，这个自定义可不是我们通过execute()或submit()传进来的自定义线程，而是Worker类中的thread变量，也就是实际运行的线程，我们看一下Worker类的构造方法。
Executor（线程执行器）
u013992890的专栏
01-10 480
通常，当我们开发一个简单的并发应用时，会创建Runnable对象，用Thread对象来运行，但如果要一个程序由大量的并发任务 这个方法就会有以下劣势1.必须实现所有与Thread对象管理相关的代码                                             2.需要为每个任务创建一个Thread对象
自定义线程池如何捕获线程异常
lqadam的博客
06-30 1536
最近写了个自定义的线程池，用于处理持续时间短、频次高的任务，逻辑上借鉴了CachedThreadPool,使用SynchronousQueue 作为任务的缓存队列，即实现没有任务进入队里，只要有空闲线程就执行任务。此外还自定义了拒接执行策略，由默认的异常拒绝执行，改为CallerRunsPolicy策略，并加了一行日志用作监控告警。 自定义线程池不是重点，本文的重点在线程池捕获异常的问题。 在实现该线程池的时候，笔者为其设置了一个ThreadFacotry,其中实现了UncaughtExceptionHan
解决python ThreadPoolExecutor 线程池中的异常捕获问题
09-17
主要介绍了解决python ThreadPoolExecutor 线程池中的异常捕获问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java Socket常见异常处理
12-22
Java Socket编程中，异常处理是确保程序稳定性和健壮性的重要环节。以下是对常见的Java Socket异常的详细解析和处理建议： 1. **java.net.BindException: Address already in use: JVM_Bind** 这个异常表明尝试...
C#多线程中的异常处理操作示例
08-26
C#多线程中的异常处理操作示例 C#多线程中的异常处理操作示例主要介绍了C#多线程中的异常处理操作，涉及C#多线程及异常的捕获、处理等相关操作技巧。 在多线程编程中，异常处理是非常重要的一方面。由于多线程的...
自定义实现Java线程池2-完善异常处理和去除同步1
08-03
本文将讨论如何在自定义线程池中完善异常处理和去除同步，以提高效率和程序的健壮性。 首先，从提供的代码片段来看，线程池的核心部分是`execute`方法，它是线程池接收并分配任务的主要入口。在这个方法中，首先...
Java线程池系列--全局异常处理的方法(有实例)
哇哇哇，真的学到了！！！
02-13 1265
execute提交的任务，会被封装成一个Runable任务，然后Runable对象被封装成一个Worker，最后在Worker的run方法里面跑runWoker方法， 里面再又调了我们最初的参数 Runable任务的任务，并且用try-catch捕获了异常，会被直接抛出去，因此我们在execute中看到了我们的任务的异常信息。本文先用示例介绍不捕获异常时的现象（即：“实例：不捕获异常”），再针对线程池的任务提交的三种方式分别说明异常处理的方法。结果如下：（捕获不到异常）结果如下：（捕获不到异常）
线程池中异常捕获
Commander_Officer的专栏
09-24 1563
1、execute方法，子线程中有异常会抛出异常； public static void main(String[] args) { ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 5, 1000, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10)); for (int i=0;i<10;i++) { threadPoolE
线程池处理异常的方法
weixin_43939924的博客
07-31 538
线程池处理异常的方法
线程池异常捕获
chilian1180的博客
09-14 716
捕获线程池的异常方法分为两种 1、一种是使用Thread和Runnable启动的线程使用UncaughtExceptionHandler 2、第二种是使用Callable和Future启动的现场，根据Future.get()捕获异常 第一种 首先创建一个线程运行类 package t...
20210601 线程池中的异常处理
陈如水的专栏
06-03 864
线程池异常处理 1，Runnable接口的run方法的完整签名，没有标识throws语句，所以方法是不会抛出checked异常的。至于RuntimeException这样的unchecked异常，由于新线程由JVM进行调度执行，如果发生了异常，也不会通知到父线程。 即：子线程中发生了异常，如果没有任何类来接手处理的话，是会直接退出的，虚拟机直接杀死线程，而不会记录任何日志。所以，如果什么都不做的话，是会出现子线程任务既没执行成功，也没有任何日志提示的“诡异”现象的。 java线程中，如果抛出未被捕获的
如何获取线程池中的异常
m0_57713282的博客
03-10 3166
1.若不需要处理返回值，则可以使用execute()方法来提交任务，当任务发生异常时，线程会抛出异常，同时我们也可以在run方法中捕获处理异常 2.若需要返回值，需要使用submit()方法时 （1）直接在run方法中捕获异常，包括未受检异常 （2）利用Future对象的get()方法，对该方法捕获异常，因为线程中出现的异常会抛给get()方法，简单来说，就是线程中出现了异常，就相当于get()方法出现了异常 （3）重写ThreadpoolExecutor的executor.afterExecute
学习笔记:线程池执行抛出异常处理
KevinLoveJava
10-17 964
1. 线程池中线程中异常尽量手动捕获 2. 通过设置`ThreadFactory`的`UncaughtExceptionHandler`可以对未捕获的异常做保底处理，通过execute提交任务，线程依然会中断，而通过submit提交任务，可以获取线程执行结果，线程异常会在get执行结果时抛出
线程池的异常处理机制
ZERO
12-27 1519
转载自：https://github.com/aCoder2013/blog/issues/3　　先上两段代码： ExecutorService threadPool = Executors.newFixedThreadPool(1); threadPool.execute(() -> { System.out.println("execute"
c++线程池异常处理代码
12-01
在C++中，线程池的异常处理主要是通过捕获和处理线程中抛出的异常来实现的。以下是一个简单的示例，展示了如何在C++线程池中使用异常处理： ```cpp #include <iostream> #include <thread> #include <vector> #include <functional> #include <stdexcept> #include <future> #include <mutex> #include <condition_variable> #include <queue> class ThreadPool { public: ThreadPool(size_t); template<class F, class... Args> auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type>; ~ThreadPool(); private: // need to keep track of threads so we can join them std::vector< std::thread > workers; // the task queue std::queue< std::function<void()> > tasks; // synchronization std::mutex queue_mutex; std::condition_variable condition; bool stop; }; // the constructor just launches some amount of workers inline ThreadPool::ThreadPool(size_t threads) : stop(false) { for(size_t i = 0;i<threads;++i) workers.emplace_back( [this] { for(;;) { std::function<void()> task; { std::unique_lock<std::mutex> lock(this->queue_mutex); this->condition.wait(lock, [this]{ return this->stop || !this->tasks.empty(); }); if(this->stop && this->tasks.empty()) return; task = std::move(this->tasks.front()); this->tasks.pop(); } try { task(); } catch(const std::exception& e) { // handle exception in task std::cerr << "Exception in thread: " << e.what() << "\n"; } catch(...) { // unknown exception in task std::cerr << "Unknown exception in thread\n"; } } } ); } // add new work item to the pool template<class F, class... Args> auto ThreadPool::enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> { using return_type = typename std::result_of<F(Args...)>::type; auto task = std::make_shared< std::packaged_task<return_type()> >( std::bind(std::forward<F>(f), std::forward<Args>(args)...) ); std::future<return_type> res = task->get_future(); { std::unique_lock<std::mutex> lock(queue_mutex); // don't allow enqueueing after stopping the pool if(stop) throw std::runtime_error("enqueue on stopped ThreadPool"); tasks.emplace([task](){ (*task)(); }); } condition.notify_one(); return res; } // the destructor joins all threads inline ThreadPool::~ThreadPool() { { std::unique_lock<std::mutex> lock(queue_mutex); stop = true; } condition.notify_all(); for(std::thread &worker: workers) worker.join(); } ``` 在这个示例中，我们创建了一个`ThreadPool`类，它有一个任务队列和一个工作线程列表。当我们向线程池提交一个任务时，这个任务会被添加到任务队列中。工作线程会从队列中取出任务并执行。如果任务中的代码抛出了异常，我们可以在任务中捕获并处理这个异常。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java程序员调优

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值