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

捕鲸叉2025-01-16 18:49

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

1. 异常捕获和处理

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

示例代码：
cpp 复制代码 
#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 的典型应用。

示例代码：
cpp 复制代码 
#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. 线程同步

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

示例代码：
cpp 复制代码 
#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 来实现异常的跨线程传播。

示例代码：
cpp 复制代码 
#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）来记录日志信息。

示例代码：
cpp 复制代码 
#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. 使用线程池

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

示例代码：
cpp 复制代码 
#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;
}

总结

在并发编程中，确保异常安全需要从多个方面着手，包括异常捕获和处理、资源管理、线程同步、异常传播、日志记录和使用线程池等。通过这些方法，可以有效地处理并发环境中的异常，提高程序的稳定性和可靠性。

相关推荐
我不是代码教父23 分钟前
[原创](Modern C++)现代C++的关键性概念: 原始字符串字面变量R“()“和LR“()“
c++·现代c++·原始字符串字面变量
冠位观测者1 小时前
【Leetcode 热题 100】215. 数组中的第K个最大元素
数据结构·算法·leetcode
忆源1 小时前
C -- 结构体内存对齐的原理
c语言·开发语言·算法
朔北之忘 Clancy1 小时前
2024 年 3 月青少年软编等考 C 语言二级真题解析
c语言·开发语言·c++·学习·算法·青少年编程·题解
躺不平的理查德1 小时前
C 语言中二维数组的退化
c语言·开发语言·数据结构·算法
oioihoii2 小时前
《C++11》深入剖析正则表达式库：解锁文本处理的高效之道
c++·mysql·正则表达式
源文雨2 小时前
新版 MacOS 无法从 /usr/local/lib 加载动态链接库的解决办法
c语言·c++·macos·unix·环境变量·动态链接库·posix
hkj88082 小时前
SM3在线哈希运行
算法
捕鲸叉2 小时前
C++并发编程之多线程环境下使用无锁数据结构的重要准则
c++·并发编程
工业甲酰苯胺2 小时前
.NET8.0多线程编码结合异步编码示例
java·算法·.net
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02Dell服务器升级ubuntu 22.04失败解决03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04玄机平台应急响应—webshell查杀05密码学原理技术-第六章-introduction to pulibc-key cryptography06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07[Docker]使用Docker部署常见的中间件08go下载依赖提示连接失败09渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了10PyTorch AMP 混合精度中grad_scaler.py的scale函数解析