智能指针的线程安全性
面试考点
这道题考察你对 shared_ptr 线程安全保证的精确理解。很多人以为 shared_ptr 是"线程安全的"就可以随便跨线程用,实际上它只有引用计数的操作是原子的,指向对象的访问和 shared_ptr 对象本身的读写并不是线程安全的。
核心概念
shared_ptr 的线程安全性分三个层次:
| 层次 | 是否线程安全 | 说明 |
|---|---|---|
| 引用计数操作 | 是(原子操作) | 多个 shared_ptr 副本可在不同线程安全地拷贝/销毁 |
| shared_ptr 对象本身 | 否 | 同一个 shared_ptr 对象不能被多线程同时读写 |
| 指向的对象 | 否 | 需要用户自己做同步保护 |
基本示例
cpp
#include <iostream>
#include <memory>
#include <thread>
#include <mutex>
#include <vector>
#include <atomic>
// ============================
// 示例1:引用计数是线程安全的
// ============================
void ref_count_safe_demo() {
auto sp = std::make_shared<int>(42);
// 在不同线程中拷贝/销毁 shared_ptr 是安全的
// 因为引用计数用原子操作维护
std::vector<std::thread> threads;
for (int i = 0; i < 10; i++) {
threads.emplace_back([sp]() {
// 每个线程持有自己的 shared_ptr 副本
// 拷贝构造时引用计数原子递增
auto local_copy = sp;
std::cout << "线程 use_count: " << local_copy.use_count() << std::endl;
// 析构时引用计数原子递减
});
}
for (auto& t : threads) {
t.join();
}
std::cout << "最终 use_count: " << sp.use_count() << std::endl; // 1
}
// ============================
// 示例2:shared_ptr 对象本身不是线程安全的
// ============================
void shared_ptr_object_unsafe_demo() {
auto sp = std::make_shared<int>(0);
// 错误:多个线程同时读写同一个 shared_ptr 对象
// 下面的代码是数据竞争(未定义行为)
/*
std::thread t1([&sp]() {
sp = std::make_shared<int>(1); // 写 sp
});
std::thread t2([&sp]() {
auto local = sp; // 读 sp(同时 t1 在写)
});
t1.join();
t2.join();
*/
// 正确做法1:用 mutex 保护
std::mutex mtx;
std::vector<std::thread> threads;
for (int i = 0; i < 5; i++) {
threads.emplace_back([&sp, &mtx, i]() {
std::lock_guard<std::mutex> lock(mtx);
sp = std::make_shared<int>(i); // 受 mutex 保护
});
}
for (auto& t : threads) {
t.join();
}
std::cout << "最终值: " << *sp << std::endl;
}
// ============================
// 示例3:C++20 atomic<shared_ptr>
// ============================
/*
// C++20 提供了 std::atomic<std::shared_ptr<T>>
// 让 shared_ptr 对象本身的操作变成原子的
void atomic_shared_ptr_demo() {
std::atomic<std::shared_ptr<int>> asp = std::make_shared<int>(0);
std::thread t1([&asp]() {
asp.store(std::make_shared<int>(1)); // 原子写
});
std::thread t2([&asp]() {
auto local = asp.load(); // 原子读
std::cout << "读到: " << *local << std::endl;
});
t1.join();
t2.join();
}
*/
// ============================
// 示例4:指向对象的访问需要保护
// ============================
class Counter {
int count_ = 0;
mutable std::mutex mutex_;
public:
// 线程安全的递增
void increment() {
std::lock_guard<std::mutex> lock(mutex_);
count_++;
}
int get() const {
std::lock_guard<std::mutex> lock(mutex_);
return count_;
}
};
void pointed_object_demo() {
// 即使多个线程持有各自的 shared_ptr 副本
// 它们指向同一个对象
// 对象本身的访问需要同步
auto counter = std::make_shared<Counter>();
std::vector<std::thread> threads;
for (int i = 0; i < 10; i++) {
threads.emplace_back([counter]() {
for (int j = 0; j < 1000; j++) {
counter->increment(); // Counter 内部有 mutex 保护
}
});
}
for (auto& t : threads) {
t.join();
}
std::cout << "计数器: " << counter->get() << std::endl; // 10000
}
// ============================
// 示例5:unique_ptr 的线程安全性
// ============================
void unique_ptr_thread_demo() {
// unique_ptr 独占所有权,通常不跨线程共享
// 但可以通过 std::move 转移所有权到另一个线程
auto up = std::make_unique<int>(42);
std::thread t([p = std::move(up)]() {
// p 在这个线程中独占
std::cout << "线程中的值: " << *p << std::endl;
});
// up 已经被移走,此处为空
// std::cout << *up; // 未定义行为!
t.join();
}
// ============================
// 示例6:weak_ptr 的线程安全性
// ============================
void weak_ptr_thread_demo() {
auto sp = std::make_shared<int>(42);
std::weak_ptr<int> wp = sp;
std::thread t([wp]() {
// lock() 是线程安全的
// 它原子地检查引用计数并创建 shared_ptr
if (auto locked = wp.lock()) {
std::cout << "weak_ptr 锁定成功: " << *locked << std::endl;
} else {
std::cout << "对象已销毁" << std::endl;
}
});
t.join();
}
int main() {
std::cout << "=== 引用计数安全 ===" << std::endl;
ref_count_safe_demo();
std::cout << "\n=== shared_ptr 对象本身 ===" << std::endl;
shared_ptr_object_unsafe_demo();
std::cout << "\n=== 指向对象的访问 ===" << std::endl;
pointed_object_demo();
std::cout << "\n=== unique_ptr ===" << std::endl;
unique_ptr_thread_demo();
std::cout << "\n=== weak_ptr ===" << std::endl;
weak_ptr_thread_demo();
return 0;
}智能指针线程安全总结
| 智能指针 | 引用计数 | 指针对象本身 | 指向的对象 |
|---|---|---|---|
| shared_ptr | 原子安全 | 不安全(需 mutex 或 C++20 atomic) | 不安全(需用户同步) |
| unique_ptr | 无引用计数 | 不跨线程共享 | 不安全 |
| weak_ptr | 原子安全 | 不安全 | lock() 是线程安全的 |
常见问题
多个线程同时读同一个 shared_ptr 安全吗?
安全。多个线程同时读(即拷贝)同一个 shared_ptr 是安全的。但如果有线程在写(reset、赋值),就需要同步。
make_shared 和 new 有什么区别?
make_shared<T>(args) 一次分配内存(对象和控制块放一起),效率更高。shared_ptr<T>(new T(args)) 两次分配。在多线程环境下 make_shared 还能避免某些异常安全问题。
C++20 的 atomic<shared_ptr> 解决了什么问题?
解决了"同一个 shared_ptr 对象被多线程同时读写"的问题。之前需要用 mutex 保护,现在可以用 atomic 接口(load、store、compare_exchange)。
适用场景
- 多线程共享资源的所有权管理
- 观察者模式(weak_ptr 防止循环引用)
- 异步回调中延长对象生命周期
- 线程间传递数据的所有权
注意事项
- 不要多线程同时读写同一个 shared_ptr 对象
- 指向的对象需要用户自己保证线程安全
- weak_ptr::lock() 是线程安全的原子操作
- C++20 提供 atomic<shared_ptr> 解决对象级原子性
- make_shared 比 new + shared_ptr 更安全更高效
总结
shared_ptr 的线程安全性是有限的:引用计数操作是原子的(多个副本可在不同线程安全拷贝/销毁),但 shared_ptr 对象本身和它指向的对象都不是线程安全的。面试中要能清楚地分出三个层次:引用计数(安全)、指针对象本身(不安全)、指向的对象(不安全)。C++20 的 atomic<shared_ptr> 解决了第二层的问题,第三层始终需要用户自己同步。