shared_ptr 引用计数相关问题-编程知识

前言

智能指针是 C++11 增加的非常重要的特性，并且也是面试的高频考点，本文主要解释以下几个问题：

引用计数是怎么共享的、怎么解决并发问题的
资源释放时，控制块的内存释放吗
weak_ptr 怎么判断对象是否已经释放

文中源码用的是 LLVM libcxx-3.5.0，为了方便理解有部分修改，关于自定义删除器和内存池的部分都删掉了。

可以想象 std::shared_ptr 对象在内存中是这样（weak_ptr 内存布局与 shard_ptr 类似）：

shared_ptr 控制块

shared_ptr

部分源码如下所示：

template <class _Tp>
class shared_ptr {public:using element_type = _Tp;private:element_type*        __ptr_;__shared_weak_count* __cntrl_;public:template<class _Yp>shared_ptr(_Yp* __p): __ptr_(__p) {__cntrl_ = new __shared_weak_count();}shared_ptr(const shared_ptr& __r) : __ptr_(__r.__ptr_),__cntrl_(__r.__cntrl_) {if (__cntrl_ != nullptr) {__cntrl_->__add_shared();}}~shared_ptr() {if (__cntrl_ != nullptr) {__cntrl_->__release_shared();}}
};

成员变量

element_type*        __ptr_;
__shared_weak_count* __cntrl_;

可以看到有两个成员变量，一个是指向资源的指针，另一个是指向控制块的指针。

class __shared_count {protected:long __shared_owners_;public:__shared_count(long __refs = 0) : __shared_owners_(__refs) {}
};class __shared_weak_count : private __shared_count {long __shared_weak_owners_;public:__shared_weak_count(long __refs = 0): __shared_count(__refs),__shared_weak_owners_(__refs) {}
};

__shared_weak_count 又继承了 __shared_count，它们各有一个成员变量分别记录 shared_ptr 和 weak_ptr 的数量。

需要注意的是计数的初始值是 0，不是 1。

复制构造函数

shared_ptr(const shared_ptr& __r) : __ptr_(__r.__ptr_),__cntrl_(__r.__cntrl_) {if (__cntrl_ != nullptr) {__cntrl_->__add_shared();}
}

复制的时候将指针指向同一个资源和同一个控制块，然后增加控制块的计数值，这样就能共享计数值了。那它是怎么保证并发安全的呢？

template <class T>
T increment(T& t) {return __sync_add_and_fetch(&t, 1);
}void __shared_count::__add_shared() {increment(__shared_owners_);
}void __shared_weak_count::__add_shared() {__shared_count::__add_shared();
}

它的实现非常简单，就是调用了原子函数将 __shared_owners_ 的值加 1。

可以看到它是通过使用原子函数来解决并发问题的，这样比使用锁的并发性要好一些。

析构函数

~shared_ptr() {if (__cntrl_ != nullptr) {__cntrl_->__release_shared();}
}

析构函数直接调用了一个 __release_shared 函数，它的代码如下：

template <class T>
T decrement(T& t)  {return __sync_add_and_fetch(&t, -1);
}bool __shared_count::__release_shared() {if (decrement(__shared_owners_) == -1) {__on_zero_shared();return true;}return false;
}void __shared_weak_count::__release_shared() {if (__shared_count::__release_shared()) {__release_weak();}
}void __shared_weak_count::__release_weak() {if (decrement(__shared_weak_owners_) == -1) {__on_zero_shared_weak();}
}

在 __shared_weak_count::__release_shared() 内首先调用 __shared_count::__release_shared() 将 __shared_owners_ 的值减 1，如果没有其他 shared_ptr 指向该资源了，就释放资源占用的内存。然后又调用 __shared_weak_count::__release_weak() 将 __shared_weak_owners_ 的值减 1，如果也没有其他 weak_ptr 指向该资源了，就释放控制块占用的资源。

可以看出当最后一个 shared_ptr 析构时，若没有其他 weak_ptr 指向该资源控制块的内存会被释放；否则不会立即释放。那控制块什么时候释放呢？请看下文。

weak_ptr

部分源码如下所示：

template<class _Tp>
class weak_ptr {public:using element_type = _Tp;private:element_type*        __ptr_;__shared_weak_count* __cntrl_;
public:weak_ptr(shared_ptr<_Yp> const& __r): __ptr_(__r.__ptr_),__cntrl_(__r.__cntrl_) {if (__cntrl_) {__cntrl_->__add_weak();}}~weak_ptr() {if (__cntrl_) {__cntrl_->__release_weak();}}shared_ptr<_Tp> lock() const {shared_ptr<_Tp> __r;__r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;if (__r.__cntrl_) {__r.__ptr_ = __ptr_;}return __r;}
};

成员变量

element_type*        __ptr_;
__shared_weak_count* __cntrl_;

成员变量与 shared_ptr 一样，也是一个指向资源的指针和一个指向控制块的指针。

构造函数

weak_ptr(shared_ptr<_Yp> const& __r): __ptr_(__r.__ptr_),__cntrl_(__r.__cntrl_) {if (__cntrl_) {__cntrl_->__add_weak();}
}

构造函数很简单，就是将指针指向 shared_ptr 所指向的资源和控制块，然后调用 __add_weak 将弱引用计数加 1。

void __shared_weak_count::__add_weak() {increment(__shared_weak_owners_);
}

析构函数

~weak_ptr() {if (__cntrl_) {__cntrl_->__release_weak();}
}

析构函数就是调用 __shared_weak_count::__release_weak()，将 __shared_weak_owners_ 的值减 1，当没有其他 shared_ptr & weak_ptr 指向该资源时释放控制块，防止内存泄露。

lock

lock 是 weak_ptr 中很重要的函数，如果我们想使用 weak_ptr 指向的资源，必须先调用 lock() 函数获取一个 shared_ptr。

shared_ptr<_Tp> lock() const {shared_ptr<_Tp> __r;__r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;if (__r.__cntrl_) {__r.__ptr_ = __ptr_;}return __r;
}__shared_weak_count* __shared_weak_count::lock()  {long object_owners = __shared_owners_;while (object_owners != -1) {if (__sync_bool_compare_and_swap(&__shared_owners_,object_owners,object_owners+1)) {return this;}object_owners = __shared_owners_;}return 0;
}