一、多线程异常处理的特殊性

在单线程程序中，异常沿着调用栈自然传播的特性非常直观。但当引入多线程后，每个线程都拥有独立的调用栈，这种隔离性使得异常无法自动跨线程传播。笔者在开发高并发交易系统时曾遇到核心痛点：子线程崩溃导致主线程完全不知情，最终引发业务逻辑雪崩。

cpp
void workerThread() {
throw std::runtime_error("Critical error in worker");
}

int main() {
std::thread t(workerThread);
t.join(); // 此处会调用std::terminate
}

这个典型例子揭示了多线程异常处理的第一个关键点：未被捕获的线程函数异常会导致整个程序终止。与单线程不同，多线程环境必须显式处理异常传播。

二、线程间异常传递三大范式

2.1 返回值封装模式

通过共享变量传递异常信息是最直接的方案。在C++11后，std::exception_ptr成为线程安全传递异常的利器：

cpp
std::exception_ptr eptr = nullptr;

void workerThread(std::exceptionptr& eptr) { try { throw std::logicerror("Calculation error");
} catch(...) {
eptr = std::current_exception();
}
}

int main() {
std::thread t(workerThread, std::ref(eptr));
t.join();

if(eptr) {
    try {
        std::rethrow_exception(eptr);
    } catch(const std::exception& e) {
        std::cerr << "Thread error: " << e.what();
    }
}

}

优势：
- 完美保留原始异常类型信息
- 支持任意异常对象的传递
- 符合RAII原则

局限：需要显式管理异常指针的生命周期

2.2 Promise-Future管道模式

C++标准库提供的异步机制天然支持异常传递。通过std::promise的set_exception()方法，可以将异常无缝传递到future端：

cpp
void processTask(std::promise&& prom) {
try {
throw std::overflowerror("Value overflow"); } catch(...) { prom.setexception(std::current_exception());
}
}

int main() {
std::promise prom;
auto fut = prom.get_future();

std::thread t(processTask, std::move(prom));

try {
    auto result = fut.get(); // 此处会抛出overflow_error
} catch(const std::exception& e) {
    std::cerr << "Task failed: " << e.what();
}
t.join();

}

性能提示：在高频调用场景下，建议复用promise/future对象以避免反复分配内存。

2.3 异常回调注册模式

对于事件驱动型架构，可以采用观察者模式实现异常通知：

cpp
class ThreadNotifier {
std::function<void(std::exceptionptr)> handler;
public:
void setHandler(std::function<void(std::exceptionptr)> f) { handler = f;
}

void executeTask() {
    try {
        // 业务逻辑
    } catch(...) {
        if(handler_) handler_(std::current_exception());
    }
}

};

三、工程实践中的关键要点

3.1 线程池的异常安全

在使用线程池时，需要特别注意任务队列的异常处理。推荐采用"任务包装器"模式：

cpp template<typename F> auto makeSafeTask(F&& f) { return [f = std::forward<F>(f)]() { try { return f(); } catch(...) { return std::current_exception(); } }; }

3.2 性能与安全的平衡

异常处理在多线程环境下会带来约5-15%的性能开销（根据LLVM实测数据）。在性能敏感场景可以采用以下优化策略：

1. 错误码局部替换：在热点路径使用错误码
2. 异常分类处理：区分可恢复异常和致命异常
3. 避免异常链过长：控制在3层调用栈内

3.3 死锁预防策略

当异常与互斥量结合时，经典的std::lock_guard可能引发死锁。推荐使用作用域锁模式：

cpp
std::mutex mtx;
void safeWrite() {
std::uniquelock lk(mtx, std::trytolock); if(!lk) throw std::runtimeerror("Failed to acquire lock");

// 临界区操作
lk.unlock();  // 显式释放避免锁带异常退出

}

四、现代C++的最佳实践

C++17引入的std::scoped_lock和std::optional为异常处理带来了新思路。结合结构化绑定可以写出更安全的代码：

cpp
std::optional<std::tuple<int, double>> compute() {
try {
return {{42, 3.14}};
} catch(...) {
return std::nullopt;
}
}

void modernStyle() {
if(auto result = compute()) {
auto [val1, val2] = result.value();
// 使用解构值
} else {
// 异常处理分支
}
}

行业趋势：Google Abseil等现代库开始推广StatusOr模式，为异常处理提供新的范式选择。