- 正确答案：shared_ptr的对象本身不是线程安全的，但其引用计数是线程安全的。多个线程可以同时访问不同的shared_ptr实例（即使它们指向同一个对象）或对同一个shared_ptr进行只读访问是安全的，但多个线程同时修改同一个shared_ptr对象（如赋值、重置）则需要外部同步。weak_ptr同理，其引用计数操作是线程安全的，但对象本身的修改操作不是。 - 解答思路： 1. 理解shared_ptr的核心机制：它通过引用计数管理动态分配对象的生命周期。当最后一个shared_ptr被销毁或重置时，所管理的对象会被自动删除。 2. 分析“线程安全”的含义：通常分为三种情况： - 多个线程读同一对象：安全 - 多个线程写同一对象：不安全，需加锁 - 多个线程读写不同实例但共享同一对象：引用计数需原子操作保证安全 3. C++标准规定：std::shared_ptr的控制块（control block）中的引用计数是原子操作实现的，因此在多线程环境下增加或减少引用计数是线程安全的。 4. 但是，如果两个线程同时对**同一个shared_ptr变量**进行写操作（例如赋值或reset），这属于数据竞争，必须由程序员使用互斥量等机制来保证同步。 - 深度知识讲解： 1. shared_ptr的内存布局： - 控制块（Control Block）：包含： - 引用计数（shared count） - 弱引用计数（weak count） - 删除器（deleter） - 分配器（allocator） - 可能还包括类型信息 - 被管理对象（managed object）当多个shared_ptr共享同一个对象时，它们共享一个控制块。该控制块中的引用计数和弱引用计数必须支持并发访问，因此C++标准要求其实现为原子操作。 2. 原子性保障： - 引用计数的递增和递减必须是原子的，通常底层使用原子整型（如std::atomic）实现。 - 在x86架构上，可能使用lock前缀指令；在其他平台上可能调用CAS（Compare-and-Swap）循环实现。 3. 典型线程安全场景与非安全场景：安全示例： ``` std::shared_ptr p = std::make_shared(); // 线程1 auto p1 = p; // 读p并构造新shared_ptr → 安全（引用计数原子增加） // 线程2 auto p2 = p; // 同上 → 安全 ``` 不安全示例： ``` std::shared_ptr p; // 线程1 p = std::make_shared(); // 写p // 线程2 p.reset(); // 写p → 数据竞争！未同步访问同一shared_ptr对象 ``` 上述情况需要加锁： ``` std::mutex mtx; std::shared_ptr p; // 线程1 { std::lock_guard lock(mtx); p = std::make_shared(); } // 线程2 { std::lock_guard lock(mtx); p.reset(); } ``` 4. weak_ptr的行为： - weak_ptr不增加强引用计数，只增加弱引用计数。 - lock()操作尝试从weak_ptr生成shared_ptr： ``` std::weak_ptr wp; // ... if (auto sp = wp.lock()) { // 使用sp，说明对象仍存活 } ``` - lock()操作是线程安全的，因为它会原子地检查强引用计数是否大于0，并在是的情况下原子地增加强引用计数。 - 但如果多个线程同时对同一个weak_ptr变量进行修改（如赋值），仍然需要外部同步。 5. 实现原理伪代码（简化版）： ``` class ControlBlock { public: std::atomic shared_count{1}; std::atomic weak_count{1}; void* data; std::function deleter; void add_shared() { ++shared_count; } bool try_add_shared() { int temp; do { temp = shared_count.load(); if (temp == 0) return false; // 对象已销毁 } while (!shared_count.compare_exchange_weak(temp, temp + 1)); return true; } void release_shared() { if (--shared_count == 0) { deleter(data); // 删除对象 release_weak(); // 可能释放控制块 } } void add_weak() { ++weak_count; } void release_weak() { if (--weak_count == 0) { delete this; // 释放控制块自身 } } }; template class shared_ptr { private: T* ptr; ControlBlock* cb; public: shared_ptr(T* p) : ptr(p), cb(new ControlBlock{.data=p}) {} shared_ptr(const shared_ptr& other) : ptr(other.ptr), cb(other.cb) { if (cb) cb->add_shared(); } shared_ptr& operator=(const shared_ptr& other) { // 注意：此处对*this的修改是非原子的，需外部同步 if (this != &other) { reset(); // 释放旧资源 ptr = other.ptr; cb = other.cb; if (cb) cb->add_shared(); } return *this; } void reset() { if (cb) { cb->release_shared(); ptr = nullptr; cb = nullptr; } } ~shared_ptr() { reset(); } }; template class weak_ptr { private: T* ptr; ControlBlock* cb; public: weak_ptr(const shared_ptr& sp) : ptr(sp.ptr), cb(sp.cb) { if (cb) cb->add_weak(); } shared_ptr lock() const { if (cb && cb->try_add_shared()) { return shared_ptr(ptr, cb); // 私有构造 } return shared_ptr(); // 空 } ~weak_ptr() { if (cb) cb->release_weak(); } }; ``` 6. 标准依据： C++11标准 [util.smartptr.shared]/4 明确指出： "Multiple threads may simultaneously access different shared_ptr objects that point to the same control block without additional synchronization." 并且引用计数的操作是原子的。 7. 总结表格： | 操作 | 是否线程安全 | 说明 | |------|--------------|------| | 不同shared_ptr读同一控制块 | 是 | 如拷贝构造 | | 同一shared_ptr被多线程读 | 是 | 只读安全 | | 同一shared_ptr被多线程写 | 否 | 需要互斥锁 | | 多线程调用weak_ptr::lock | 是 | 原子检查并增加强引用 | | 同一weak_ptr被多线程修改 | 否 | 需要同步 | 因此，在实际开发中，若要在多线程环境中共享智能指针变量，应结合互斥量使用；若只是传递副本，则无需额外同步。

腾讯TEG云架平后台开发凉经

全站热榜

创作者周榜