当前位置：首页 > news >正文

C++ `unique_ptr` 多线程使用

news 来源：原创 2025/4/21 5:32:40

C++ `unique_ptr` 多线程使用

一、核心结论

操作同一个 unique_ptr：必须加锁（所有权转移是非原子操作）
访问被管理对象：若对象非线程安全，仍需额外同步
独立 unique_ptr 实例：不同线程操作不同实例时无需加锁

二、错误案例（未加锁导致数据竞争）

#include <iostream>
#include <memory>
#include <thread>// 全局 unique_ptr（危险！）
std::unique_ptr<int> unsafe_ptr;void unsafe_thread() {// 多线程同时修改同一个 unique_ptrunsafe_ptr = std::make_unique<int>(42);
}int main() {std::thread t1(unsafe_thread);std::thread t2(unsafe_thread);t1.join();t2.join();if (unsafe_ptr) {std::cout << "危险操作结果: " << *unsafe_ptr << "\n";} else {std::cout << "指针已丢失\n"; // 可能输出}return 0;
}

可能输出（结果不确定）：

指针已丢失
Segmentation fault (core dumped)  // 可能崩溃

三、正确实现（加锁保护所有权转移）

#include <iostream>
#include <memory>
#include <thread>
#include <mutex>// 全局资源
std::unique_ptr<int> safe_ptr;
std::mutex ptr_mutex;void safe_writer(int val) {std::lock_guard<std::mutex> lock(ptr_mutex);safe_ptr = std::make_unique<int>(val);  // 安全修改
}void safe_reader() {std::unique_ptr<int> local_copy;{std::lock_guard<std::mutex> lock(ptr_mutex);if (safe_ptr) {local_copy = std::make_unique<int>(*safe_ptr);  // 安全拷贝值}}if (local_copy) {std::cout << "安全读取: " << *local_copy << "\n";}
}int main() {std::thread writers[2];std::thread readers[2];// 启动写入线程for (int i = 0; i < 2; ++i) {writers[i] = std::thread(safe_writer, i * 100);}// 启动读取线程for (int i = 0; i < 2; ++i) {readers[i] = std::thread(safe_reader);}for (auto& t : writers) t.join();for (auto& t : readers) t.join();return 0;
}

典型输出（结果确定）：

安全读取: 100
安全读取: 100

四、分步详解

步骤1：理解所有权独占性

unique_ptr 的内存布局：
```
[对象指针] --> 被管理对象
```
所有权转移（移动构造/赋值）会清空原指针
两个线程同时修改同一指针会导致 数据竞争

步骤2：加锁保护所有权操作

std::lock_guard<std::mutex> lock(mtx);
global_ptr = std::move(new_ptr);  // 安全转移所有权

步骤3：安全访问被管理对象

若对象需要多线程访问：

class ThreadUnsafeObject {int counter = 0;
public:void increment() { ++counter; }  // 非线程安全
};std::unique_ptr<ThreadUnsafeObject> obj_ptr;void thread_work() {std::unique_ptr<ThreadUnsafeObject> local;{std::lock_guard<std::mutex> lock(mtx);local = std::move(obj_ptr);  // 独占所有权}// 现在可以安全使用 local（单线程独占）if (local) {local->increment();}// 交还所有权{std::lock_guard<std::mutex> lock(mtx);obj_ptr = std::move(local);}
}

五、编译与测试

编译命令：

g++ -std=c++17 -pthread -o unique_ptr_thread unique_ptr_thread.cpp

运行正确案例：

./unique_ptr_thread
安全读取: 100
安全读取: 100

六、最佳实践总结

场景	处理方案
多线程修改同一 `unique_ptr`	必须使用 `std::mutex` 保护
多线程访问被管理对象	通过转移所有权实现独占访问，或为对象本身添加同步机制
高频所有权转移	使用 `std::deque` 缓冲任务，减少锁竞争
需要共享访问	改用 `std::shared_ptr`（注意其不同的线程安全规则）

七、高级模式：所有权传递

#include <queue>
#include <mutex>template<typename T>
class SafeQueue {std::queue<std::unique_ptr<T>> queue_;std::mutex mtx_;
public:void push(std::unique_ptr<T> ptr) {std::lock_guard<std::mutex> lock(mtx_);queue_.push(std::move(ptr));}std::unique_ptr<T> pop() {std::lock_guard<std::mutex> lock(mtx_);if (queue_.empty()) return nullptr;auto ptr = std::move(queue_.front());queue_.pop();return ptr;}
};// 使用示例
SafeQueue<int> safe_queue;void producer() {safe_queue.push(std::make_unique<int>(42));
}void consumer() {auto ptr = safe_queue.pop();if (ptr) {std::cout << "消费: " << *ptr << "\n";}
}