《shared_ptr源码剖析》

【shared_ptr导读】上一节，我们为大家介绍了unique_ptr的底层原理和实现。相对于unique_ptr，shared_ptr也是被大家广泛使用的智能指针，shared_ptr内部的原理是怎样的？shared_ptr是多线程安全的吗？

     

   本文将以Centos标准库为基础，剖析shared_ptr的源码，shared_ptr主要包含两个部分：shared_ptr_base.h和shared_ptr.h，虽然涉及的文件不多，但为了实现一套完备的内存托管方案出来，gcc还是设计很多类出来。且看如下图片，笔者将结合图片逐步为您剖析shared_ptr托管内存的原理和细节。

1. shared_ptr结构和源码     

     我们直接使用的shared_ptr定义在shared_ptr.h文件中，shared_ptr仅仅只是定义了些接口给我们使用，该类本身并没有执行任何操作，具体的内存管理以及引用计数相关的还需要关注它的父类__shared_ptr，shared_ptr定义如下：

template<typename _Tp>class shared_ptr : public __shared_ptr<_Tp>{    public:      constexpr shared_ptr() noexcept          :__shared_ptr<_Tp>() { }      shared_ptr(const shared_ptr&) noexcept = default;            template<typename _Tp1>       explicit shared_ptr(_Tp1* __p)         : __shared_ptr<_Tp>(__p) { }           template<typename _Tp1, typename _Deleter>      shared_ptr(_Tp1* __p, _Deleter __d)        : __shared_ptr<_Tp>(__p, __d) { }           template<typename _Deleter>      shared_ptr(nullptr_t __p, _Deleter __d)        : __shared_ptr<_Tp>(__p, __d) { }            ......};

2. __shared_ptr结构和源码   

     __shared_ptr内部维护了一个__shared_count类型的成员，__shared_count顾名思义就是托管内存被引用的计数，当__shared_ptr执行拷贝构造或者拷贝赋值时，__shared_count内部将对其内部维护的引用计数执行++操作。

template<typename _Tp, _Lock_policy _Lp>class __shared_ptr{public:   typedef _Tp   element_type;   constexpr __shared_ptr() noexcept   : _M_ptr(0), _M_refcount(){ }   template<typename _Tp1>   explicit __shared_ptr(_Tp1* __p)      : _M_ptr(__p), _M_refcount(__p)   {       __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)       static_assert(sizeof(_Tp1) > 0, "incomplete type" );       __enable_shared_from_this_helper(_M_refcount, __p, __p);   }      template<typename _Tp1, typename _Deleter>    __shared_ptr(_Tp1* __p, _Deleter __d)     : _M_ptr(__p), _M_refcount(__p, __d)   {     __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)     __enable_shared_from_this_helper(_M_refcount, __p, __p);   }      template<typename _Tp1>   __shared_ptr& operator=(const __shared_ptr<_Tp1, _Lp>& __r)           noexcept   {      _M_ptr = __r._M_ptr;      _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw      return *this;   }         ......     private:  ......  _Tp*    _M_ptr;  // Contained pointer.  __shared_count<_Lp>  _M_refcount; //Reference counter.}; 

3. __shared_count的源码和结构     

      __shared_count其实是个类，从名字可知，__shared_count也是和托管内存引用计数相关的类，__shared_count类内部维护了_Sp_counted_base类型的成员指针_M_pi，_M_pi又指向_Sp_counted_base派生类对象_Sp_counted_ptr的地址。

template<_Lock_policy _Lp>class __shared_count{template<typename _Ptr>explicit __shared_count(_Ptr __p) : _M_pi(0){   __try   {       _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);   }   __catch(...){        delete __p;        __throw_exception_again;   }}......private:  friend class __weak_count<_Lp>;  _Sp_counted_base<_Lp>*  _M_pi; }

  _Sp_counted_ptr类型内部持有托管内存的指针_M_ptr, 这样_M_pi内部就既可以控制引用计数，又可以在最后释放托管内存_M_ptr。_Sp_counted_ptr的结构很简单。

template<typename _Ptr, _Lock_policy _Lp>class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>{ public:  explicit _Sp_counted_ptr(_Ptr __p)    : _M_ptr(__p) { }  virtual void _M_dispose() noexcept  { delete _M_ptr; }  virtual void _M_destroy() noexcept  { delete this; }  virtual void* _M_get_deleter(const std::type_info&)  { return 0; }  _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;  _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; protected:   _Ptr      _M_ptr;  // copy constructor must not throw};

     _Sp_counted_base便是shared_ptr托管内存的核心，内存释放与否与它维护的引用计数_M_use_count、_M_weak_count相关。那为啥有两个引用计数？难道shared_ptr内部维护两份不同的内存？

template<_Lock_policy _Lp = __default_lock_policy>class _Sp_counted_base : public _Mutex_base<_Lp>{public:     _Sp_counted_base() noexcept   :_M_use_count(1), _M_weak_count(1)   { }         virtual ~_Sp_counted_base() noexcept   { }     virtual void _M_dispose() noexcept = 0;         virtual void _M_destroy() noexcept   {       delete this;   }   virtual void* _M_get_deleter(const std::type_info&) = 0;   void _M_add_ref_copy()   {       //引用计数额递增，都是调GNU C++ 库的接口，保证引用计数原子化递增       __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1);    }   void _M_add_ref_lock();   void _M_release() noexcept   {    _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)    {      /*      使用 GNU C++库中的__exchange_and_add_dispatch函数      将_M_use_count的值减去1，并将原来的值与1进行比较。      如果比较结果为真，即原来的值为1，那么表明原来的值为1，      并且现在已经将其减为0。     */      _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);            /*_M_use_coun减为0时便调用_M_dispose()接口释放托管的内存        _M_ptr，而_M_ptr是由派生类_Sp_counted_ptr进行管理。        进而内存释放操作由_Sp_counted_ptr类负责，        当前类的_M_dispose()仅仅是个纯虚接口。       */            /*释托管内存的操作并非线程安全的。        gcc标准库仅仅保证了托管内引用计数的线程安全      */      _M_dispose();            if (_Mutex_base<_Lp>::_S_need_barriers)      {         _GLIBCXX_READ_MEM_BARRIER;         _GLIBCXX_WRITE_MEM_BARRIER;      }     /*      使用 GNU C++库中的__exchange_and_add_dispatch函数      将_M_weak_count的值减去1，并将原来的值与1进行比较。      如果比较结果为真，即原来的值为1，那么表明原来的值为1，      并且现在已经将其减为0。    */      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)      {         _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);         /*           释放内存时，并没有进行任何的加锁保护，           也说明了一点shared_ptr托管的内存在多线程的环境下是非线程安全的         */         _M_destroy();      }    }  }   void _M_weak_add_ref() noexcept   {        __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1);    }    void _M_weak_release() noexcept   {       _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);       if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)       {          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);          if (_Mutex_base<_Lp>::_S_need_barriers)          {             _GLIBCXX_READ_MEM_BARRIER;             _GLIBCXX_WRITE_MEM_BARRIER;          }          _M_destroy();       }   }   long _M_get_use_count() const noexcept   {      return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED);   }private:     _Sp_counted_base(_Sp_counted_base const&) = delete;   _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;   _Atomic_word  _M_use_count;   _Atomic_word  _M_weak_count;};

     _M_use_count表示托管对象的引用计数，控制托管对象的释放，当引用计数为0时，最终调用和托管内存相关的类_Sp_counted_ptr的接口_M_dispose()释放内存。__shared_ptr拷贝时，__shared_count也会随之进行拷贝，__shared_count的拷贝会最终转调_Sp_counted_base的接口_M_add_ref_copy()。

~__shared_count() noexcept{   if (_M_pi != nullptr)      _M_pi->_M_release();}__shared_count(const __shared_count& __r) noexcept  : _M_pi(__r._M_pi){    if (_M_pi != 0)_M_pi->_M_add_ref_copy();
}__shared_count& operator=(const __shared_count& __r) noexcept{_Sp_counted_base<_Lp>* __tmp = __r._M_pi;   if (__tmp != _M_pi){       if (__tmp != 0)          __tmp->_M_add_ref_copy();       if (_M_pi != 0)          _M_pi->_M_release();      _M_pi = __tmp;   }   return *this;
}

      _M_weak_count表示管理对象的引用计数，管理对象也是一块内存，这块内存是在初始化第一个shared_ptr时被申请出来的。

template<typename _Ptr>explicit __shared_count(_Ptr __p) : _M_pi(0)
{   __try   {       _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);   }   __catch(...){       delete __p;       __throw_exception_again;   }}

       _M_destroy释放内存时，也需要依赖_M_weak_count进行控制，weak_ptr内部其实持有的就是这个管理对象的指针，当weak_ptr拷贝时，管理对象的引用计数_M_weak_count就会增加，当_M_weak_count为0时，管理对象_M_pi就会析构且释放内存。那_M_weak_count是如何进行加减的？ 

 4.__weak_count的源码和结构

template<_Lock_policy _Lp>class __weak_count{public:  constexpr __weak_count() noexcept : _M_pi(0)  {  }  __weak_count(const __shared_count<_Lp>& __r) noexcept      : _M_pi(__r._M_pi)   {       if (_M_pi != 0)         _M_pi->_M_weak_add_ref();   }      __weak_count(const __weak_count<_Lp>& __r) noexcept    : _M_pi(__r._M_pi)   {       //拷贝构造，增加引用计数       if (_M_pi != 0)         _M_pi->_M_weak_add_ref();   }   ~__weak_count() noexcept   {        /析构，释放引用计数        if (_M_pi != 0)          _M_pi->_M_weak_release();   }   __weak_count<_Lp>& operator=(const __shared_count<_Lp>& __r) noexcept   {        _Sp_counted_base<_Lp>* __tmp = __r._M_pi;        if (__tmp != 0)           __tmp->_M_weak_add_ref();        if (_M_pi != 0)            _M_pi->_M_weak_release();        _M_pi = __tmp;        return *this;   }       __weak_count<_Lp>& operator=(const __weak_count<_Lp>& __r) noexcept   {       _Sp_counted_base<_Lp>* __tmp = __r._M_pi;       if (__tmp != 0)          __tmp->_M_weak_add_ref();       if (_M_pi != 0)          _M_pi->_M_weak_release();        _M_pi = __tmp;        return *this;   }       void _M_swap(__weak_count<_Lp>& __r) noexcept    {        _Sp_counted_base<_Lp>* __tmp = __r._M_pi;        __r._M_pi = _M_pi;        _M_pi = __tmp;    }        long _M_get_use_count() const noexcept    {         return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0;     }        ......private:    friend class __shared_count<_Lp>;    _Sp_counted_base<_Lp>*  _M_pi;};

       由文章首页可以看到__shared_count、__weak_count共同持有同一个_Sp_counted_base类指针，而__weak_count是用于控制__weak_ptr的，当__weak_ptr进行拷贝析构时，__weak_count会做响应的加减。无论是增加引用计数_M_weak_add_ref，还是减少引用计数_M_weak_release，最终调用就是_Sp_counted_base类中的接口。

void _M_weak_add_ref() noexcept{     __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }void _M_weak_release() noexcept{  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);  if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1)                 == 1)  {     _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);     /判是否需要内存屏障     if (_Mutex_base<_Lp>::_S_need_barriers)     {       /如果需要就开启内存读、写屏障的操作，确保多线程环境下，        _GLIBCXX_READ_MEM_BARRIER;        _GLIBCXX_WRITE_MEM_BARRIER;      }      //确保释放当前管理类对象内存操作的安全性      _M_destroy();   }}virtual void _M_destroy() noexcept{     delete this; }

   重点关注：引用计数_M_weak_count、_M_use_count始终由 _Sp_counted_base负责，托管对象内存由_Sp_counted_ptr负责，管理对象的内存（即由_M_weak_count控制的内存）由_Sp_counted_base负责。5. enable_shared_from_this      假如我们需要把当前类对象以shared_ptr包裹起来，返回给外部使用，那么可以将类继承自enable_shared_from_this，看了下enable_shared_from_this的源码，shared_from_this()接口只是将内部持有的weak_ptr转换成shared_ptr。

template<typename _Tp>class enable_shared_from_this{protected:  constexpr enable_shared_from_this() noexcept { }  enable_shared_from_this(const enable_shared_from_this&) noexcept { }  enable_shared_from_this&  operator=(const enable_shared_from_this&) noexcept  {      return *this;   }  ~enable_shared_from_this() { }public:  shared_ptr<_Tp> shared_from_this()  {      return shared_ptr<_Tp>(this->_M_weak_this);   }    shared_ptr<const _Tp> shared_from_this() const  {     return shared_ptr<const _Tp>(this->_M_weak_this);  }private:   ......   mutable weak_ptr<_Tp>  _M_weak_this;};

      shared_from_this()接口最后还是会转调到__shared_ptr类的拷贝构造函数，将托管的内存_M_ptr拷贝（浅拷贝），_M_refcount引用计数进行拷贝构造，将_M_use_count递增1。

template<typename _Tp1>explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)   : _M_refcount(__r._M_refcount) // may throw{   /*    *STL库类型检查，    *确保__weak_pt托管的对象类型能隐私转换成__shared_pt托管的对象类型。    */   __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)   _M_ptr = __r._M_ptr;}