C++异常处理在并发编程中的挑战 异步任务中的异常捕获

#include <iostream>
#include <future>
#include <exception>

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    std::thread t([&prom]() {
        try {
            // 模拟一个可能抛出异常的任务
            throw std::runtime_error("Something went wrong in the thread!");
            prom.set_value(42); // 如果没有异常，设置结果
        } catch (...) {
            prom.set_exception(std::current_exception()); // 捕获异常并存储
        }
    });

    try {
        fut.get(); // 获取结果，如果promise存储了异常，这里会重新抛出
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }

    t.join();
    return 0;
}

#include <iostream>
#include <mutex>
#include <stdexcept>

class SafeResource {
private:
    std::mutex mtx;
    int data;

public:
    SafeResource() : data(0) {}

    void updateData(int value) {
        std::lock_guard<std::mutex> lock(mtx);
        if (value < 0) {
            throw std::invalid_argument("Value must be non-negative.");
        }
        data = value;
    }

    int getData() const {
        std::lock_guard<std::mutex> lock(mtx);
        return data;
    }
};

int main() {
    SafeResource resource;
    try {
        resource.updateData(-1);
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }

    std::cout << "Data: " << resource.getData() << std::endl; // 仍然可以安全访问
    return 0;
}

#include <iostream>
#include <exception>
#include <cstdlib>

void my_terminate() {
    std::cerr << "Unhandled exception!" << std::endl;
    std::abort(); // 终止程序
}

int main() {
    std::set_terminate(my_terminate);

    throw std::runtime_error("This exception will not be caught.");

    return 0;
}