C++并发编程之异常安全性增强

在并发编程中，异常安全是一个非常重要的方面，因为并发环境下的错误处理比单线程环境更加复杂。当多个线程同时执行时，异常不仅可能影响当前线程，还可能影响其他线程和整个程序的稳定性。以下是一些增强并发程序异常安全性的方法，并附有示例代码。

1. 异常捕获和处理

在多线程程序中，每个线程都应该有自己的异常捕获机制。常见的做法是在每个线程的入口点（如线程函数）中使用 try-catch 块来捕获和处理异常。

示例代码：

#include <iostream>
#include <thread>
#include <exception>void threadFunction() {try {// 模拟可能抛出异常的代码throw std::runtime_error("An error occurred in the thread");} catch (const std::exception& e) {std::cerr << "Exception caught in thread: " << e.what() << std::endl;// 可以在这里进行日志记录、资源清理等操作}
}int main() {std::thread t(threadFunction);t.join();return 0;
}

2. 资源管理

使用 RAII（Resource Acquisition Is Initialization）技术来管理资源，确保资源在异常情况下也能正确释放。C++ 中的智能指针（如 std::unique_ptr 和 std::shared_ptr）和 std::lock_guard 等都是 RAII 的典型应用。

示例代码：

#include <iostream>
#include <thread>
#include <memory>
#include <mutex>std::mutex mtx;void threadFunction() {try {std::unique_ptr<int> resource(new int(42));std::lock_guard<std::mutex> lock(mtx);// 模拟可能抛出异常的代码throw std::runtime_error("An error occurred in the thread");} catch (const std::exception& e) {std::cerr << "Exception caught in thread: " << e.what() << std::endl;}
}int main() {std::thread t(threadFunction);t.join();return 0;
}

3. 线程同步

在多线程环境中，确保线程间的同步非常重要。使用互斥锁、条件变量等同步原语时，要确保在异常情况下不会导致死锁或资源泄露。

示例代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>std::mutex mtx;
std::condition_variable cv;
bool ready = false;void prepare() {try {std::this_thread::sleep_for(std::chrono::milliseconds(1000));std::lock_guard<std::mutex> lock(mtx);ready = true;cv.notify_one();} catch (const std::exception& e) {std::cerr << "Exception caught in prepare: " << e.what() << std::endl;// 可以在这里进行日志记录、资源清理等操作}
}void waitAndPrint() {try {std::unique_lock<std::mutex> lock(mtx);cv.wait(lock, [] { return ready; });std::cout << "Ready is true" << std::endl;} catch (const std::exception& e) {std::cerr << "Exception caught in waitAndPrint: " << e.what() << std::endl;}
}int main() {std::thread t1(prepare);std::thread t2(waitAndPrint);t1.join();t2.join();return 0;
}

4. 异常传播

在多线程环境中，异常可能需要从一个线程传播到另一个线程。可以使用 std::promise 和 std::future 来实现异常的跨线程传播。

示例代码：

#include <iostream>
#include <thread>
#include <future>void threadFunction(std::promise<int> promise) {try {// 模拟可能抛出异常的代码throw std::runtime_error("An error occurred in the thread");promise.set_value(42);} catch (const std::exception& e) {promise.set_exception(std::current_exception());}
}int main() {std::promise<int> promise;std::future<int> future = promise.get_future();std::thread t(threadFunction, std::move(promise));t.join();try {int value = future.get();std::cout << "Value: " << value << std::endl;} catch (const std::exception& e) {std::cerr << "Exception caught in main: " << e.what() << std::endl;}return 0;
}

5. 日志记录

在多线程程序中，记录详细的日志是诊断问题的重要手段。可以使用日志库（如 spdlog）来记录日志信息。

示例代码：

#include <iostream>
#include <thread>
#include <spdlog/spdlog.h>void threadFunction() {try {// 模拟可能抛出异常的代码throw std::runtime_error("An error occurred in the thread");} catch (const std::exception& e) {spdlog::error("Exception caught in thread: {}", e.what());// 进行其他必要的处理}
}int main() {auto logger = spdlog::stdout_color_mt("console");std::thread t(threadFunction);t.join();return 0;
}

6. 使用线程池

线程池可以更好地管理和复用线程，减少线程创建和销毁的开销。线程池通常会处理线程中的异常，并确保线程池的正常运行。

示例代码：

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>class ThreadPool {
public:ThreadPool(size_t numThreads) : stop(false) {for (size_t i = 0; i < numThreads; ++i) {threads.emplace_back([this] {while (true) {std::function<void()> task;{std::unique_lock<std::mutex> lock(queueMutex);condition.wait(lock, [this] { return stop || !tasks.empty(); });if (stop && tasks.empty()) {return;}task = std::move(tasks.front());tasks.pop();}try {task();} catch (const std::exception& e) {std::cerr << "Exception caught in thread pool: " << e.what() << std::endl;}}});}}~ThreadPool() {{std::unique_lock<std::mutex> lock(queueMutex);stop = true;}condition.notify_all();for (std::thread& t : threads) {t.join();}}template <typename Func, typename... Args>auto enqueue(Func&& func, Args&&... args) -> std::future<decltype(func(args...))> {using return_type = decltype(func(args...));auto task = std::make_shared<std::packaged_task<return_type()>>(std::bind(std::forward<Func>(func), std::forward<Args>(args)...));std::future<return_type> res = task->get_future();{std::unique_lock<std::mutex> lock(queueMutex);if (stop) {throw std::runtime_error("Enqueue on stopped ThreadPool");}tasks.emplace([task]() { (*task)(); });}condition.notify_one();return res;}private:std::vector<std::thread> threads;std::queue<std::function<void()>> tasks;std::mutex queueMutex;std::condition_variable condition;bool stop;
};void simulateWork() {throw std::runtime_error("An error occurred in the task");
}int main() {ThreadPool pool(4);std::future<void> future = pool.enqueue(simulateWork);try {future.get();} catch (const std::exception& e) {std::cerr << "Exception caught in main: " << e.what() << std::endl;}return 0;
}