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_ptr
unsafe_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";
}
}
通过合理应用这些模式，可以在多线程环境中安全高效地使用 unique_ptr，充分发挥其独占所有权的优势。
