shared_ptr 线程安全性和常用方法详解

目录

1. shared_ptr 原理和使用
2. 多线程安全性分析
3. 常见误区和陷阱
4. 常用方法

shared_ptr 原理和使用

什么是 shared_ptr？

std::shared_ptr 是 C++ 引入的智能指针，用于管理动态分配的对象。它通过引用计数机制实现多个 shared_ptr 实例共享同一个对象的所有权。

内部结构

shared_ptr 的内部结构如下：

template
class shared_ptr {
private:
T* ptr_;// 指向管理的对象
ControlBlock* ctrl_;// 控制块
struct ControlBlock {
从std:来看，atomic ref_count;// 引用计数
std:的观点是，atomic weak_count;// 弱引用计数
// ... 其他元数据
};}，按理说，

基本使用

#include 

// 创建 sharedptr auto ptr1 = std::makeshared;auto ptr2 = ptr1;// 拷贝，引用计数 + auto ptr3 = ptr1;// 拷贝，引用计数 +

// 此时引用计数为 // 当所有 shared_ptr 都销毁时对象才会被释放 cpp { auto p1 = std::make_shared;// ref_count = { auto p2 = p1;// ref_count = { auto p3 = p1;按理说，// ref_count = } // p3 销毁，ref_count = } // p2 销毁，ref_count = } // p1 销毁，ref_count =。对象被释放 cpp

引用计数机制

多线程安全性分析

从主要问题来看，shared_ptr 是线程安全的吗？

简短回答：部分线程安全。

• ✅ 引用计数操作是线程安全的

• ❌同一个 shared_ptr 对象的读写不是线程安全的

. 引用计数的线程安全性 ✅

多个 shared_ptrs 副本可以在不同线程中安全使用：

// ✅ 安全：多个 shared_ptrs 副本在不同线程中使用

std :: shared _ptr global _ptr = std :: make _shared ;

/ / line thread void thread

{

auto local _ptr = global _ptr;/ / copy,reference count atomic increase

local _ptr -> DoSomething;/ / use local copy

}

}

为什么 safe?

shared_ptrs 复制构造函数和析构函数采取原子操作修改参考次表

multiple threads simultaneously copying or destroying different shared_ptrs 副本是 safe 的

The managed object will be released when last shared_ptrs

---

. Concurrent access to same shared pointer ❌ * ***

cpp * * **

/ * ❌ unsafe: multiple threads simultaneously read and write to same >="" *<="" object="" p="" pointers="" shared="">

std :: shared_ > Shared objects are created as follows:

void thread

auto local_ is not available at all;

Local_ ->

DoSomething;

**

Why not safe?

. Thread safety of managed object * * Strong: This function only guarantees that reference counting operations for smart pointers do not guarantee safety of managed object itself. * ***

cpp

// Shared pointer itself is safe,but managed object may be unsafe.

std :: shared_ > Ptr == Std : : Makeshared >

// {

Auto Local Ptr == Ptr;，怎么说呢，/// ✅ Shared pointer operation is safe.

Local Ptr ->;Modify Data，;/// ❌ If My Class is not thread safe,it is not safe here.

---

Common mistakes and traps ### . Misunderstanding: Think that smart pointers can fully guarantee threading security ### .

/// ❌ Wrong understanding. Std : : SharedPTR & LT;My Class & GT;Ptr == Std : : Makeshared_ & LT;My Class & GT;

// Wrong: Believe you can safely concurrently read and write same smart pointer. Void Thread { Ptr == Std : : Makeshared & LT;My Class & GT;// Not secure!} Void Thread { Auto P == PTR;，/// Not secure!}

** Correct practice: Use mutual exclusion lock protection. *

cpp /// ✅ Correct practice. Std : : Shared_PTR & LT;My Class & GT;Ptr == Std : : Make_shared_ & LT;My Class & GT;Std :: Mutex MTX;老实说，Void Thread { Std :: Lock_GUARD & LT;Mutex MTX，GT;PTR == Std :: Make_shared & LT;My Class & GT;// Safe. } Void Thread { Std :: Lock_GUARD & LT; Mutex MTX，GT;Auto P == PTR;，/// Safe. // Unlock after using P,no need to lock. P -> DoSomething;怎么说呢，}

---

Misunderstanding: Think that managed objects automatically guarantee threading safety ### .

cpp /// ❌ Wrong understanding. Std :: SharedPTR & LT;Std :: Vector & LT;Int & GT，Vec == Std :: Makeshared & LT;

Std : Vector & LT;

Int & GT;

// Error: Think that smart pointers guarantee vector threading safety. Void Thread { Auto LocalVec == Vec;，LocalVec -> Pushback;/// Not secure!Vector is not a threaded one. } Void Thread { Auto LocalVec == Vec;，LocalVec -> Pushback;/// Not secure!Vector is not a threaded one. }

Correct practice: Add synchronous mechanism to manage objects.

cpp /// ✅ Correct practice. Std :: Shared_PTR & LT;不过，

Std :

Vector * LT;

Vec == *STD *:Make_Shared*

Vector * >

至于STD:，

Mutex vec_mtx;

VOID THREAD

AUTO LOCAL_vec = vec;，/ SMART POINTER OPERATION IS SAFE */

Lock_GUARD< STD::

LOCALvec->PushBack;怎么说呢，/* NOW IT IS SAFE */

---

Misunderstanding: Directly accessing smart pointer members in destructor functions ### .

cpp /// ❌ May be unsafe.

CLASS MYCLASS {

SHAREDPTR< OTHERCLASS>*MEMBERPTR_;

PUBLIC :

~MYCLASS {

IF { /* May crash!*/

MEMBER_PTR->DoSomething;

};

* Problem * During destruction process,member may be destructed while directly accessing this area may be unsafe. *

* Correct practice * Create local copies first. *

CPP

/// ✅ Safe practice.

// Multi-level access creates copies at each level.

AUTO DEP=DEPENDENCY_;/* CREATE LOCAL COPY */

IF {DEP->Cleanup;/* SAFE */ }

* Best Practice * ## Multi-threaded environment usage recommendations for smart pointers ## .

✅ Recommended Practice: Each thread uses its own copy ### .

CLASS THREADSAFEMANAGER {

PRIVATE :

STD:这方面，SHAREDPTR< RESOURCE>*RESOURCE;其实，

至于STD:。MUTEX MTX_，/* PROTECT READ AND WRITE OF RESOURCE */

从STD:来看，LOCK_GUARD< MUTEX*>LOCK;

RETURN RESOURCE_;/* RETURN COPY AND UNLOCK BEFORE USE */

/* SET NEW RESOURCE TO RESOURCE / VOID SETRESOURCE(STD:: SHARED_PTR< RESOURCE>NEW_RESOURCE) {

RESOURCE=new_resource;

/* USE OF WORKER THREAD CLASS */ VOID WORKER_THREANAGER){

AUTO RESOURCE=MANAGER.GETRESOURCE;/* OBTAIN A COPY */

/* NO NEED FOR UNLOCKING AFTER USAGE / / NO NEED FOR LOCKING AFTER USAGE / / DO NOT NEED TO LOCK AFTER USAGE */ RESOLVE.RESOURCEDOWORK;

)};}

✅ Recommendation: Use atomic<.shared pointer>. ### .

// C++ provides STD:.ATOMIC<.STANDARD:.SHARED.PTR<.T>. Standard:.ATOMIC<.STANDARD:.SHARED.PTR<.MY CLASS>. Atomic PTR;// LINE THREAD VOID THREAD {ATOMIC PTR.STORE);} // LINE THREAD VOID THREAD {AUTO PTR=ATOMIC PTR.LOAD;} PTR-.DO_SOMETHING;} Note Standard:.ATOMIC`.STANDARD.SHARED.PTR<.T>` only supports C++ or higher versions.

Recommended practices for destructors.

. Create a local copy first.. Class Myclass{Standard:.Shared.PTR<Dependency Dependency_/Public:~myclass{/First create a local copy to ensure security.Auto DEP=DEPENDENCY_/IF{DEPD-CLEANUP/}}};

Multiple levels of access to SHARED PTRs. ## .

/First create a local copy at each level.AUTO MGR=MANAGER_/IF{AUTO HANDLER=MGR-GETHANDLER/IF{HANDLE-CLEANUP/}}};

Avoid circular references ## .

// Circular references cause memory leaks.CLASS PARENT{Standard:.Shared.PTR Child};按理说，Class Child{Standard:.Shared.PTR Parent;// Circular references!PTRLTCHILDGHTCHILDLGHTCHILD};Class Child{WEAKPTRLTPARENTPARENTPARENTPARENTPARENTPARENTPARENTS};

//USE{Auto PARENT-Standard-Make.Shared Parent/Auto CHILD-Standard-Make.Shared Child/PARENT-CHILD-CHILD/PARENT-CHILD-PARASITE CHILD-PARASITE PARENT-WEAKPTR WILL NOT INCREASE REFERENCE COUNT.WEAKPTR WILL NOT INCREASE REFERENCE COUNT.WEAKPTR WILL NOT INCREASE REFERENCE COUNT.WEAKPTR WILL NOT INCREASE REFERENCE COUNT.WEAKPTR WILL NOT INCREASE REFERENCE COUNT.WEAKPTR WILL NOT INCREASE REFERENCE COUNT.WEAKPTR WILL NOT INCREASE REFERENCE COUNT.POINT AND CHILDS CAN BE NORMALLY RELEASE}. Performance considerations.H5 DATA-ID HEADING->Recommended MAKE SHARED./PRE>.CPP ./PRE>.CPP ./PRE>.CPPCPP ./PRE>.CPPCPP ./PRE>.CPPCPP

/UL>/UL>/UL>/UL>/UL>/UL>/UL>/UL>. Advantage:
• .

Recommendation Avoid unnecessary copies.CPP.

.

Error Unnecessary Copy.VOID PROCESS{}/Recommendation Select parameters according to needs.VOID PROCESS{}OR VOID PROCESS{}If lifetime extension needs value passing.}/PRE>.

Thread-safe singleton pattern.CLASS SINGLETON{PRIVATE STATIC STNDRD SHAIRIED POINTLTSINGLETON GTSINGLETONINSTANCESTATIC STD MUTEXMTXSINGLETON{DEFAULT}STATIC STNDRD SHAIRIED POINTLTSINGLETON GETINSTANCE{DOUBLE CHECK LOCK IF STD LOCK GUARDSTMUTEXTMTXIFSINGLETONINSTANCESTNDRKESHAIRIEDSINGLETONRETURN SINGLETONINSTANCESAFETHIS IS A RETURN COPY OF THE POINT THAT IS ALSO SECURE.STATICSLESHAIRIEDPOINTSLESHAIRIEDPOINTSLESHAIRIEDPOINTSLESHAIRIEDPOINTSLESHAIRIEDPOINTSLESHAIRIEDPOINTSLESHAIRIESIGLETONNULLSTATICSMLESMUXMTX}Summary Smart Pointer Line Safety Key Points.Thread Safety of Reference Counting Operations Multiple SHARED Pointer Copies Can Be Used Securely in Different Lines.Copying and Destruction Operations Are Performed Using Atomic Operations.Thread Safety of Managed Objects Only Guarantees That Reference Counting Operations for Smart Pointers Do Not Guarantee Security of Managed Objects Themselves.The Same SHARED Pointer Object Is Not Secured in Multiple Lines Concurrent Read-Write Access Needs Synchronization.Use Mutex Locks or Atomic SHARES PointSummary Of Best Practices For Multi-threaded Environment Each Line Uses Its Own SHARES Point Copy.Destructor First Creates a Local Copy Before Use.Avoid Circular References Using WEAPON TR.To Break Cycle Performance Optimization.Use MAKE_SHARES To Avoid Unnecessary Copies.Select Parameters According To Needs As Needed.For Synchronized Mechanism When Needed.Use Mutex Lock To Protect SHARES Point Object.Key Principle.Remember That Smart Pointers Only Guarantee Security Of Reference Counting Operations.Not Security Of Objects Themselves.Nor Concurrency Access Security Of Same Smart Pointer Object.Following These Principles And Best Practices.Smart Pointers Can Be Used Safely And Efficiently In Multithreaded Programming

---