智能指针shared_ptr之引用计数

        上篇文章 🔗智能指针unique_ptr 介绍了 unique_ptr，而 shared_ptr 与 unique_ptr 的主要不同之处在于可以有多个 shared_ptr 管理同一个对象，这点是通过拷贝构造函数以及引用计数机制来实现的。

shared_ptr(const std::__1::shared_ptr<_Tp> &);
shared_ptr(std::__1::shared_ptr<_Tp> &&);
std::__1::shared_ptr<_Tp> & operator=(const std::__1::shared_ptr<_Tp> &);
std::__1::shared_ptr<_Tp> & operator=(std::__1::shared_ptr<_Tp> &&);

        可以看到构造函数不仅支持右值传参，也支持左值。至于引用计数，应该是有个数据成员来记录引用个数。先看下 shared_ptr 定义：

template<class _Tp>
class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr
{
    ...
private:
    _Tp*      __ptr_;
    __shared_weak_count* __cntrl_;
    ...
}

        只有两个数据成员，其中 __ptr_ 看着是指向原生指针的，那另一个大概率就保存引用计数相关信息了，但是是 __shared_weak_count 类型，其实它也是一个类：

class _LIBCPP_TYPE_VIS __shared_weak_count
    : private __shared_count
{
    long __shared_weak_owners_;

public:
    _LIBCPP_INLINE_VISIBILITY
    explicit __shared_weak_count(long __refs = 0) _NOEXCEPT
        : __shared_count(__refs),
          __shared_weak_owners_(__refs) {}
    ...
}

        它自身只有一个数据成员 __shared_weak_owners_，但从名称可看出是与智能指针 weak_ptr 对应的，但是它还私有继承类 __shared_count：

class _LIBCPP_TYPE_VIS __shared_count
{
    ...
protected:
    long __shared_owners_;
    ...

public:
    _LIBCPP_INLINE_VISIBILITY
    explicit __shared_count(long __refs = 0) _NOEXCEPT
        : __shared_owners_(__refs) {}
    ...
}

        它的数据成员 __shared_owners_ 就是我们要寻找的记录引用计数用的，但是它的初始值是 0，而当调用 use_count() 方法是返回的是1，且看调用链：

// shared_ptr
long use_count() const _NOEXCEPT {
    return __cntrl_ ? __cntrl_->use_count() : 0;
}
// __shared_weak_count
long use_count() const _NOEXCEPT {
    return __shared_count::use_count();
}
// __shared_count
long use_count() const _NOEXCEPT {
    return __libcpp_relaxed_load(&__shared_owners_) + 1;
}

        到此就清楚了，返回的引用数是在程序中做了加1的处理，至于为什么这么做，目前还没想到什么合理的解释，哪位小伙伴清楚的话还请指点下哈！

        那又是如何影响引用计数的呢？譬如下面这段代码：

{
    shared_ptr<A> s (new A(5));
    cout << "s count:" << s.use_count() << endl;
    shared_ptr<A> t(s);
    cout << "t count:" << t.use_count() << endl;
    s.reset();
    cout << "t count:" << t.use_count() << endl;
}

        运行后输出结果如下：

s count:1
t count:2
t count:1

        这里得看下 shared_ptr 的拷贝构造函数的实现了：

// shared_ptr
template<class _Tp>
inline
shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT
    : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_)
{
    if (__cntrl_)
        __cntrl_->__add_shared();
}
// __shared_weak_count
void __add_shared() _NOEXCEPT {
  __shared_count::__add_shared();
}

// __shared_count
void __add_shared() _NOEXCEPT {
  __libcpp_atomic_refcount_increment(__shared_owners_);
}

        一路跟下来最终还是调用的类 __shared_count 中的 __add_shared() 方法，注意这里用到了 __libcpp_atomic_refcount_increment() 方法，是为了保证计数的原子性。再看看 reset() 又是如何释放并让当前计数减1的。

template<class _Tp>
inline
void
shared_ptr<_Tp>::reset() _NOEXCEPT
{
    shared_ptr().swap(*this);
}

        先是调用构造函数 shared_ptr() 生成了一个匿名的空 shared_ptr 指针，然后调用 swap() 方法和当前对象交换，也就是智能指针 s。

swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
                                    is_nothrow_move_assignable<_Tp>::value)
{
    _Tp __t(_VSTD::move(__x));
    __x = _VSTD::move(__y);
    __y = _VSTD::move(__t);
}

        这里的交换并不是简单的赋值交换，而是引入了移动语义，使得刚才生成的匿名 shared_ptr 指针变成要释放的智能指针 s。当交换完退出 reset() 方法代码块时，就自动执行析构函数：

// shared_ptr
template<class _Tp>
shared_ptr<_Tp>::~shared_ptr()
{
    if (__cntrl_)
        __cntrl_->__release_shared();
}
// __shared_weak_count
void __release_shared() _NOEXCEPT {
    if (__shared_count::__release_shared())
        __release_weak();
}
// __shared_count
bool __release_shared() _NOEXCEPT {
    if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
        __on_zero_shared();
        return true;
    }
    return false;
}

        最终也是调用了类 __shared_count 中的 __release_shared() 方法对其进行原子减1，但相比加1时多了个判断，即没有任何 shared_ptr 指针指向该对象时，还要调用 __on_zero_shared() 方法。

// __shared_ptr_pointer
template <class _Tp, class _Dp, class _Alloc>
void
__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT
{
    __data_.first().second()(__data_.first().first());
    __data_.first().second().~_Dp();
}

        该方法是类 __shared_ptr_pointer 的成员函数，似乎有点突然，但如果看看 shared_ptr 的构造函数如何实现的就知道了。

template<class _Tp>
template<class _Yp>
shared_ptr<_Tp>::shared_ptr(_Yp* __p,
                            typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
    : __ptr_(__p)
{
    unique_ptr<_Yp> __hold(__p);
    typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
    typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT > _CntrlBlk;
    __cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT());
    __hold.release();
    __enable_weak_this(__p, __p);
}

        __cntrl_ 其实就是个 __shared_ptr_pointer 类对象，而这个类又继承自 __shared_weak_count：

template <class _Tp, class _Dp, class _Alloc>
class __shared_ptr_pointer
    : public __shared_weak_count
{
    __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
public:
    _LIBCPP_INLINE_VISIBILITY
    __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
        :  __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {}
    ...
};

        但类 __shared_weak_count 是个抽象类，因为它有个纯虚成员函数：

private:
    virtual void __on_zero_shared_weak() _NOEXCEPT = 0;

        所以实际上是类 __shared_ptr_pointer 管理着 shared_ptr 内存的分配与销毁。

        至此关于 shared_ptr 的引用计数部分就介绍差不多了。通篇下来，感觉更多还是记述，只能说知道个大概，但还缺少些自己的理解，希望以后有机会再深入领会这块吧。