单例Exchanger模板类并发交换T对象异常及参数生命周期问询

让我们一步步解决你遇到的两个问题，先从导致Exchanger返回错误结果的核心问题说起。

一、Exchanger类的致命问题：悬空指针引发未定义行为 #

你的Exchanger<T>::exchange方法里踩了一个C++并发编程中常见的生命周期陷阱：

• 函数参数t是值传递的局部副本，它的生命周期只存在于当前exchange函数调用的栈帧里。
• 当你执行p1 = &t或者p2 = &t时，你保存的是这个局部变量的内存地址。一旦第一个分支里的线程进入wait状态，或者第二个分支执行到return，这个局部变量t就会被销毁，对应的栈内存会被标记为可复用。此时p1/p2就变成了悬空指针——指向已经被释放的内存。后续访问*p1或*p2完全是未定义行为，表现出来就是随机值覆盖、程序崩溃等奇怪现象。

修复思路：存储对象而非指针 #

我们需要在Exchanger类内部存储实际的T对象，而不是指针，这样就能保证对象的生命周期和Exchanger实例绑定，彻底避免悬空指针。这里我用std::optional<T>来存储，它能完美处理T没有默认构造函数的情况；如果你的T一定有默认构造，直接用T p1, p2;也可以。

二、关于int exchange(int t)的疑问：未定义行为的巧合 #

你问为什么函数结束销毁参数副本t后，指针p还能访问到值——这其实是未定义行为的巧合表现：

• 函数执行完毕后，局部变量t占用的栈内存并不会被立即清零，只是标记为可以被后续栈操作复用。如果此时你立刻访问*p，刚好这块内存还没被其他操作改写，你就能看到原来的值，但这完全是不可靠的。
• 只要后续有任何函数调用或者栈操作，这块内存就会被覆盖，此时访问*p就会得到随机值，甚至直接导致程序崩溃。这种行为是C++标准明确禁止的，绝对不能依赖。

修复后的完整代码 #

#include <mutex>
#include <condition_variable>
#include <thread>
#include <iostream>
#include <sstream>
#include <vector>
#include <random>
#include <optional>

template <typename T>
class Exchanger {
 inline static Exchanger* instance;
 inline static std::once_flag inited;
 std::mutex mutex;
 std::condition_variable to_exchange;
 std::optional<T> p1; // 用optional存储，无需默认构造
 std::optional<T> p2;
 bool ready = false;
 Exchanger(){};
 ~Exchanger(){};
public:
 static Exchanger* getInstance() {
 std::call_once(inited, []{ instance = new Exchanger(); });
 return instance;
 }
 T exchange(T t) {
 std::unique_lock lock(mutex);
 if (!ready) {
 p1 = std::move(t); // 移动语义减少拷贝开销
 ready = true;
 to_exchange.wait(lock, [this]{return !ready;});
 auto result = *p2;
 p2.reset(); // 清空存储，避免残留
 return result;
 } else {
 p2 = std::move(t);
 ready = false;
 to_exchange.notify_one();
 auto result = *p1;
 p1.reset();
 return result;
 }
 }
};

// 原测试用的exchange函数，仅用于演示悬空指针问题
int* p = nullptr;
void exchange(int t) {
 p = &t;
}

int main(int argc, char **argv) {
 int x = 10;
 exchange(x);
 // 注意：下面的访问是未定义行为，结果不可靠
 std::cout << "悬空指针访问测试（结果随机）：" << *p << std::endl;

 std::vector<std::thread> traders;
 for (int i = 0; i < 4; i++) {
 traders.emplace_back([i]{
 std::this_thread::sleep_for(std::chrono::seconds(rand() % 2));
 std::stringstream msg1;
 msg1 << "thread " << std::this_thread::get_id() << " willing to trade " << i << std::endl;
 std::cout << msg1.str();
 std::stringstream msg2;
 msg2 << "thread " << std::this_thread::get_id() << " got " << Exchanger<int>::getInstance()->exchange(i) << std::endl;
 std::cout << msg2.str();
 });
 }
 for (int i = 4; i < 8; i++) {
 traders.emplace_back([i]{
 std::this_thread::sleep_for(std::chrono::seconds(rand() % 2));
 std::stringstream msg1;
 msg1 << "thread " << std::this_thread::get_id() << " willing to trade " << i << std::endl;
 std::cout << msg1.str();
 std::stringstream msg2;
 msg2 << "thread " << std::this_thread::get_id() << " got " << Exchanger<int>::getInstance()->exchange(i) << std::endl;
 std::cout << msg2.str();
 });
 }
 for (auto &t: traders) {
 if (t.joinable()) {
 t.join();
 }
 }
 return 0;
}

额外补充 #

• 使用std::move(t)是为了避免不必要的对象拷贝，尤其是当T是大对象（比如std::string、自定义类）时，能显著提升性能。
• 修复后的Exchanger类现在可以安全地支持成对线程交换对象，不会再出现悬空指针导致的随机值问题。
• 如果你不需要支持无默认构造的T类型，把std::optional<T>换成普通的T变量也是完全可以的。

内容的提问来源于stack exchange，提问作者Antonio Santoro