C++线程池库的异常处理机制是什么

在C++中，线程池库通常使用std::exception_ptr来处理异常。当一个任务在线程池中执行时，如果抛出了异常，线程池会捕获这个异常并将其存储为std::exception_ptr。然后，当调用者尝试获取任务的结果时，线程池会重新抛出这个异常。

以下是一个简单的示例，展示了如何在C++线程池中处理异常：

#include<
    iostream>
    
#include<
    thread>
    
#include <
    future>
    
#include<
    vector>
    
#include <
    stdexcept>


class ThreadPool {

public:
    ThreadPool(size_t num_threads) {
    
        for (size_t i = 0;
     i <
     num_threads;
 ++i) {
    
            workers.emplace_back(&
    ThreadPool::work, this);

        }

    }


    ~ThreadPool() {
    
        for (auto&
 worker : workers) {

            if (worker.joinable()) {
    
                worker.join();

            }

        }

    }
    

    template<
    typename F, typename... Args>
    
    auto 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();

        tasks.push([task]() {

            try {
    
                (*task)();

            }
 catch (...) {
    
                task->
    set_exception(std::current_exception());

            }

        }
    );
    
        return res;

    }


private:
    void work() {

        while (true) {
    
            std::function<
    void()>
     task;
    
            tasks.pop(task);

            if (!task) {
    
                return;

            }
    
            task();

        }

    }
    

    std::vector<
    std::thread>
     workers;
    
    SafeQueue<
    std::function<
    void()>
    >
     tasks;

}
    ;


int main() {
    
    ThreadPool pool(4);


    auto result = pool.enqueue([]() {
    
        throw std::runtime_error("An error occurred");
    
        return 42;

    }
    );


    try {
    
        std::cout <
    <
     "Result: "<
    <
     result.get()<
    <
     std::endl;

    }
     catch (const std::exception&
 e) {
    
        std::cerr <
    <
     "Caught exception: " <
    <
     e.what()<
    <
     std::endl;

    }
    

    return 0;

}
    

在这个示例中，我们创建了一个简单的线程池，它可以接受任务并在工作线程中执行它们。当任务抛出异常时，线程池会捕获这个异常并将其存储为std::exception_ptr。当调用者尝试获取任务的结果时，线程池会重新抛出这个异常。在main函数中，我们捕获并处理了这个异常。

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！