浅谈shared_ptr及shared_ptr涉及到的循环引用问题

 起初在C++标准库里面是没有智能指针的,直到C++11才加入了shared_ptr和unique_ptr以及weak_ptr。

最早的智能指针在Boost库里面,Boost库是为C++标准库提供扩展的一些C++程序的总称,由Boost社区组织开发维护。


   “智能”指针看上去是指针,实际上是附加了语义的对象。shared_ptr与scoped_ptr一样包装了new操作符在堆上分配的动态对象,但它实现的是引用计数型的智能指针 ,可以被自由地拷贝和赋值,在任意的地方共享它,当没有代码使用(引用计数为0)它时才删除被包装的动态分配的对象。shared_ptr也可以安全地放到标准容器中,并弥补了auto_ptr因为转移语义而不能把指针作为STL容器元素的缺陷。任何情况下都不要使用auto_ptr。


一、模拟实现shared_ptr的基本功能:
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

template<class T>
class SharpedPtr
{
public:
    SharpedPtr(T* ptr = 0)//构造函数
        :_ptr(ptr)
        , _pCount(NULL)
    {
        if (ptr)
        {
            _pCount = new int(1);
        }
    }
    SharpedPtr(const SharpedPtr<T>& ap)//拷贝构造
        :_ptr(ap._ptr)
        , _pCount(ap._pCount)
    {
        if (_ptr)
        {
            ++UseCount();
        }
    }
    //ap1 = ap2;赋值运算符重载
    //①ap1内部封装的指针为空
    //②ap1独占一块空间
    //③ap1与其他对象共享一块空间
    SharpedPtr& operator=(const SharpedPtr<int>& ap)
    {
        if (this != &ap)
        {
            if (_ptr)
            {
                Release();
            }
            //ap1与其他对象共享一块空间
            _ptr = ap._ptr;
            _pCount = ap._pCount;
            ++UseCount();
        }
        return *this;
    }
    //析构函数
    ~SharpedPtr()
    {
        Release();
    }
    //检查引用计数并释放空间
    void Release()
    {
        if (0 == --UseCount())
        {
            delete _pCount;
            _pCount = NULL;
            delete _ptr;
            _ptr = NULL;
        }
    }
    //获取引用计数
    int& UseCount()
    {
            return *_pCount;
    }
//为了使其更像一个指针,所完成的基本操作
    T* operator->()
    {
        return _ptr;
    }

    T& operator*()
    {
        return *_ptr;
    }
private:
    T* _ptr;
    int* _pCount;
};
void TestSharpedPtr()
{
    SharpedPtr<int> ap1(new int(10));
    SharpedPtr<int> ap2(new int(20));
    SharpedPtr<int> ap3(ap1);
    SharpedPtr<int> ap4;
    ap4 = ap1;
    *ap1 = 1;
    *ap2 = 2;
    *ap3 = 3;
    *ap4 = 4;
}
int main()
{
    TestSharpedPtr();
    return 0;
}

虽然我们上面的程序看起来还可以,但实际上还存在以下问题:
但是还存在以下问题:
  1. 线程安全问题:

  shared_ptr 本身不是 100% 线程安全的。它的引用计数本身是安全且无锁的,但对象的读写则不是,因为 shared_ptr 有两个数据成员,读写操作不能原子化。shared_ptr 的线程安全级别和内建类型、标准库容器、string 一样,即:

  • 一个 shared_ptr 实体可被多个线程同时读取;
  • 两个的 shared_ptr 实体可以被两个线程同时写入,“析构”算写操作;
  • 如果要从多个线程读写同一个 shared_ptr 对象,那么需要加锁。
2.对于管理的特定类型的指针的释放不合理造成的程序崩溃:

我们都会有一种普遍的认知,shared_ptr智能指针只能用来管理动态开辟的空间,实际不然,shared_ptr是用来管理资源的,这里的资源并不仅仅是动态开辟的空间,还有例如:打开文件,其维护一个文件指针,那么在程序快要结束时,需要关闭文件;
还有就是使用malloc来动态开辟的空间,需要使用free来释放,否则,不管管理什么资源,都使用delete来释放空间,有时就会使得程序崩溃。
所以呢,我们就需要为其定制删除器
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
//为解决文件指针
struct Fclose
{
    void operator()(FILE*& fp)
    {
        cout<< "Fclose()" << endl;
        fclose(fp);
        fp = NULL;
    }
};
//为解决malloc开辟的空间
template<class T>
struct Free
{
    void operator()(T*& p)
    {
        free(p);
        p = NULL;
    }
};
//一般情况下(使用new动态开辟的空间)
template<class T>
class Delete
{
public :
    void operator()(T*& p)
    {
        delete p;
        p = NULL;
    }
};
template<class T, class Destory = Delete<T> >
class SharedPtr
{
public :
    SharedPtr(T* ptr = 0)//构造函数
        :_ptr(ptr)
        ,_pCount(NULL)
    {
        if (_ptr)
        {
            _pCount = new int(1);
        }
    }
    SharedPtr(const SharedPtr<T>& sp)//拷贝构造函数
        :_ptr(sp._ptr)
        , _pCount(sp._pCount)
    {
        if (_ptr)
        {
            ++GetRef();
        }
    }
    //sp1 = sp2
    SharedPtr<T>& operator=(const SharedPtr<T>& sp)
    {
        //可有三种情况:①sp1._ptr = NULL  ②sp1的引用计数为1  ③sp1的引用计数大于1
        if (this != &sp)
        {
            Release();
            _ptr = sp._ptr;
            _pCount = sp._pCount;
            ++GetRef();
        }
        return *this;
    }
    //辅助函数
    void Release()
    {
        if (_ptr && --GetRef() == 0)
        {
            Destory()(_ptr);
            delete _pCount;
            _pCount = NULL;
        }
    }
 //析构函数
    ~SharedPtr()
    {
        Release();
    }

    int& GetRef()
    {
        return *_pCount;
    }
private:
    T* _ptr;
    int* _pCount;
};
void Test2()
{
    FILE* sp1 = fopen("test.txt", "rb");
    SharedPtr<FILE, Fclose> sp2(sp1);

    int* sp3 = (int*)malloc(sizeof(int));
    SharedPtr<int, Free<int> >sp4(sp3);

    int* sp5 = new int(1);
    SharedPtr<int> sp6(sp5);
}

int main()
{
    Test2();
    return 0;
}

3.循环引用问题;
先来看下面一个示例:

下面的代码使用的都是c++标准库里的智能指针,源码也是。boost库的智能指针和c++标准库中的智能指针在底层实现机制是一样的。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include"boost/shared_ptr.hpp"


struct Node
{
    Node(int value)
    :_value(value)
    {
        cout << "Node()" << endl;
    }
    ~Node()
    {
        cout << "~Node()" << endl;
    }
    shared_ptr<Node> _prev;
    shared_ptr<Node> _next;
    int _value;
};

void Test2()
{
    shared_ptr<Node> sp1(new Node(1));
    shared_ptr<Node> sp2(new Node(2));
    cout << sp1.use_count() << endl;
    cout << sp2.use_count() << endl;
    sp1->_next = sp2;
    sp2->_prev = sp1;
    cout << sp1.use_count() << endl;
    cout << sp2.use_count() << endl;
}

int main()
{
    Test2();
    return 0;
}

可以看出,在这里我们使用了双向链表来说明这个问题,并且双向链表中的指针都是使用shared_ptr来维护的,在这里我使用的是标准库里的 shared_ptr智能指针。

从下图可以看出,构造的sp1和sp2在出它们的作用域时(即Test2())都没有被析构,从而造成了内存泄漏。



  由于先构造的后释放,后构造的先释放可知,先释放的是sp2,那么因为它的引用计数为2,减去1之后就成为了1,不能释放空间,因为还有其他的对象在管理这块空间。但是sp2这个变量已经被销毁,因为它是栈上的变量,但是sp2管理的堆上的空间并没有释放。
接下来释放sp1,同样,先检查引用计数,由于sp1的引用计数也是2,所以减1后成为1,也不会释放sp1管理的动态空间。

通俗点讲:就是sp2要释放,那么必须等p1释放了,而sp1要释放,必须等sp2释放,所以,最终,它们两个都没有释放空间。

所以,造成了内存泄漏。

下面让我们一起来剖析源码是怎样实现这种情况的?




上图只给出了简单的过程,下面贴出调用过程完整的源码:

shared_ptr() _NOEXCEPT
        {   // construct empty shared_ptr
        }

    _Ptr_base()
        : _Ptr(0), _Rep(0)
        {   // construct
        }
上面的构造函数连续调用了两次,构造节点内的_prev和_next。

template<class _Ux>
        explicit shared_ptr(_Ux *_Px)
        {   // construct shared_ptr object that owns _Px
        _Resetp(_Px);
        }

_Ptr_base()
        : _Ptr(0), _Rep(0)
        {   // construct
        }


    template<class _Ux>
        void _Resetp(_Ux *_Px)
        {   // release, take ownership of _Px
        _TRY_BEGIN  // allocate control block and reset
        _Resetp0(_Px, new _Ref_count<_Ux>(_Px));
        _CATCH_ALL  // allocation failed, delete resource
        delete _Px;
        _RERAISE;
        _CATCH_END
        }


_Ref_count(_Ty *_Px)
        : _Ref_count_base(), _Ptr(_Px)
        {   // construct
        }

_Ref_count_base()
        {   // construct
        _Init_atomic_counter(_Uses, 1);
        _Init_atomic_counter(_Weaks, 1);
        }


template<class _Ux>
        void _Resetp0(_Ux *_Px, _Ref_count_base *_Rx)
        {   // release resource and take ownership of _Px
        this->_Reset0(_Px, _Rx);
        _Enable_shared(_Px, _Rx);
        }
    };

    void _Reset0(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
        {   // release resource and take new resource
        if (_Rep != 0)
            _Rep->_Decref();//没有执行
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
        }

inline void _Enable_shared(const volatile void *, const volatile void *)
    {   // not derived from enable_shared_from_this; do nothing
    }


所以,构造智能指针sp1主要完成两件事情:

1、给引用计数开辟空间,并初始化uses和weaks均为1
2、将节点的空间交给_Rep来管理,将引用计数的空间交给_Ptr来管理。
sp2和sp1的构造过程相同。



同样:下面贴出上述过程的源码:
_Ty *operator->() const _NOEXCEPT
        {   // return pointer to resource
        return (this->_Get());
        }

_Myt& operator=(const _Myt& _Right) _NOEXCEPT
        {   // assign shared ownership of resource owned by _Right
        shared_ptr(_Right).swap(*this);
        return (*this);
        }
shared_ptr(const _Myt& _Other) _NOEXCEPT
        {   // construct shared_ptr object that owns same resource as _Other
        this->_Reset(_Other);
        }

_Ptr_base()
        : _Ptr(0), _Rep(0)
        {   // construct
        }

template<class _Ty2>
        void _Reset(const _Ptr_base<_Ty2>& _Other)
        {   // release resource and take ownership of _Other._Ptr
        _Reset(_Other._Ptr, _Other._Rep);
        }

void _Reset(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
        {   // release resource and take _Other_ptr through _Other_rep
        if (_Other_rep)
            _Other_rep->_Incref();
        _Reset0(_Other_ptr, _Other_rep);
        }


void _Incref()
        {   // increment use count
        _MT_INCR(_Mtx, _Uses);
        }

void _Reset0(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
        {   // release resource and take new resource
        if (_Rep != 0)
            _Rep->_Decref();
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
        }

上述调用过程,主要完成:

1.将sp2管理的引用计数中的uses加至2
2.sp1中的_next节点中的_Rep管理sp2的引用计数,_next节点中的_Ptr管理sp2节点


sp2->_prev = sp1;
其实调用过程同sp1->_next = sp2调用过程,主要完成:

1.将sp1管理的引用计数中的uses加至2
2.sp2中的_prev节点中的_Rep管理sp1的引用计数,_prev节点中的_Ptr管理sp1节点.

总体结构图如下:


                     图1


下面我们一起来看看析构的过程:

先析构sp2,下面是析构sp2的过程,可以看出没有释放空间(节点空间和引用计数空间),sp2析构完成之后,再去析构sp1,sp1的析构过程和sp2的析构过程相同,所以由此可知,一共有四块动态开辟的空间,但是都没有释放。

这里只贴出sp2的析构过程。
  ~shared_ptr() _NOEXCEPT
        {   // release resource
        this->_Decref();
        }

void _Decref()
        {   // decrement reference count
        if (_Rep != 0)
            _Rep->_Decref();
        }


void _Decref()
        {   // decrement use count
        if (_MT_DECR(_Mtx, _Uses) == 0)//uses为2,经过这条语句之后减为1
            {   // destroy managed resource, decrement weak reference count
            _Destroy();//不执行
            _Decwref();//不执行
            }
        }

由此引入weak_ptr,可以这么说,weak_ptr是为了shared_ptr而生,weak_ptr就是为解决shared_ptr的循环引用问题而产生的。
它必须依赖于shared_ptr,不能直接管理一块动态开辟的空间。

-------------------------------------------------------------------------
下面让我们一起来看weak_ptr是如何来解决循环引用的。

因为下面的过程和上面的过程大多数相同,所以在这里就不详细讲解了。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include"boost/shared_ptr.hpp"

struct Node
{
    Node(int value)
    :_value(value)
    {
        cout << "Node()" << endl;
    }
    ~Node()
    {
        cout << "~Node()" << endl;
    }
   weak_ptr<Node> _prev;
   weak_ptr<Node> _next;
    int _value;
};
void Test2()
{
    shared_ptr<Node> sp1(new Node(1));
    shared_ptr<Node> sp2(new Node(2));
    cout << sp1.use_count() << endl;
    cout << sp2.use_count() << endl;
    sp1->_next = sp2;
    sp2->_prev = sp1;
    cout << sp1.use_count() << endl;
    cout << sp2.use_count() << endl;
}

int main()
{
    Test2();
    return 0;
}

使用源码分析上述过程:

先来看构造sp1和sp2的过程:
shared_ptr<Node> sp1(new Node(1));
shared_ptr<Node> sp2(new Node(2));
Node(int value)
    :_value(value)
    {
        cout << "Node()" << endl;
    }
//与上面的区别在这里(Node里的_prev和_next分别为weak_ptr智能指针)
weak_ptr() _NOEXCEPT
        {   // construct empty weak_ptr object
        }
_Ptr_base()
        : _Ptr(0), _Rep(0)
        {   // construct
        }
上面过程同样连续执行两次(构造_prev和_next)
下面过程也是执行两次(构造sp1和sp2),和上面的过程相同
template<class _Ux>
        explicit shared_ptr(_Ux *_Px)
        {   // construct shared_ptr object that owns _Px
        _Resetp(_Px);
        }
_Ptr_base()
        : _Ptr(0), _Rep(0)
        {   // construct
        }
template<class _Ux>
        void _Resetp(_Ux *_Px)
        {   // release, take ownership of _Px
        _TRY_BEGIN  // allocate control block and reset
        _Resetp0(_Px, new _Ref_count<_Ux>(_Px));
        _CATCH_ALL  // allocation failed, delete resource
        delete _Px;
        _RERAISE;
        _CATCH_END
        }
_Ref_count(_Ty *_Px)
        : _Ref_count_base(), _Ptr(_Px)
        {   // construct
        }
_Ref_count_base()
        {   // construct
        _Init_atomic_counter(_Uses, 1);
        _Init_atomic_counter(_Weaks, 1);
        }

template<class _Ux>
        void _Resetp0(_Ux *_Px, _Ref_count_base *_Rx)
        {   // release resource and take ownership of _Px
        this->_Reset0(_Px, _Rx);
        _Enable_shared(_Px, _Rx);
        }
    };

void _Reset0(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
        {   // release resource and take new resource
        if (_Rep != 0)
            _Rep->_Decref();
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
        }
inline void _Enable_shared(const volatile void *, const volatile void *)
    {   // not derived from enable_shared_from_this; do nothing
    }


sp1->_next = sp2;
sp2->_prev = sp1;
源码分析上面两个语句的执行过程:
 
sp1->_next = sp2;
  _Ty *operator->() const _NOEXCEPT
        {   // return pointer to resource
        return (this->_Get());
        }
template<class _Ty2>
        weak_ptr& operator=(const shared_ptr<_Ty2>& _Right) _NOEXCEPT//_Right就是sp2
        {   // assign from _Right
        this->_Resetw(_Right);
        return (*this);
        }
template<class _Ty2>
        void _Resetw(const _Ptr_base<_Ty2>& _Other)//_Other为sp2
        {   // release weak reference to resource and take _Other._Ptr
        _Resetw(_Other._Ptr, _Other._Rep);
        }
template<class _Ty2>
        void _Resetw(_Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)
        {   // point to _Other_ptr through _Other_rep
        if (_Other_rep)//增加sp2的弱引用计数,sp2.weaks加1 = 2
            _Other_rep->_Incwref();
        if (_Rep != 0)//sp1->next._Rep为0
            _Rep->_Decwref();//不执行
        _Rep = _Other_rep;//sp1->_next._Rep = sp2._Rep
        _Ptr = _Other_ptr;//sp1->_next._Ptr = sp2._Ptr
        }
void _Incwref()
        {   // increment weak reference count
        _MT_INCR(_Mtx, _Weaks);//将weaks从1修改为2
        }
sp2->_prev = sp1;
_Ty *operator->() const _NOEXCEPT
        {   // return pointer to resource
        return (this->_Get());
        }
template<class _Ty2>//_Right就是sp1
        weak_ptr& operator=(const shared_ptr<_Ty2>& _Right) _NOEXCEPT
        {   // assign from _Right
        this->_Resetw(_Right);
        return (*this);
        }
template<class _Ty2>//_Other为sp1
        void _Resetw(const _Ptr_base<_Ty2>& _Other)
        {   // release weak reference to resource and take _Other._Ptr
        _Resetw(_Other._Ptr, _Other._Rep);
        }
template<class _Ty2>
        void _Resetw(_Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)
        {   // point to _Other_ptr through _Other_rep
        if (_Other_rep)//增加sp1的弱引用计数,sp1.weaks加1 = 2
            _Other_rep->_Incwref();
        if (_Rep != 0)//sp2->prev._Rep为0
            _Rep->_Decwref();//不执行
        _Rep = _Other_rep;//sp2->_prev._Rep = sp1._Rep
        _Ptr = _Other_ptr;//sp2->_prev._Ptr = sp1._Ptr
        }
void _Incwref()
        {   // increment weak reference count
        _MT_INCR(_Mtx, _Weaks);
        }

                            图2


分析图2与图1的区别:

1)sp1和sp2节点内的_prev和_next均为弱引用计数(_weak_ptr)
2)sp1和sp2的引用计数中的_weaks为2,_uses为1,和上面相反。

源码分析析构过程:

   
//析构sp2
~shared_ptr()
        {   // release resource
        this->_Decref();
        }
void _Decref()
        {   // decrement reference count
        if (_Rep != 0)//sp2._Rep不为0
            _Rep->_Decref();
        }
void _Decref()
        {   // decrement use count
        if (_MT_DECR(_Mtx, _Uses) == 0)//sp2.uses从1减为0
            {   // destroy managed resource, decrement weak reference count
            _Destroy();
            _Decwref();
            }
        }
//释放节点空间(清理节点内资源(包括sp2->next和sp2->prev))
virtual void _Destroy()
        {   // destroy managed resource
        delete _Ptr;
        }
-------------------------------------------------------------------------------------
下面都是清理sp2节点内的资源
~Node()
    {
        cout << "~Node()" << endl;
    }
~weak_ptr()//清理sp2._next(弱智能指针)
        {   // release resource
        this->_Decwref();
        }
void _Decwref()
        {   // decrement weak reference count
        if (_Rep != 0)//sp2->next._Rep为0
            _Rep->_Decwref();//不执行
        }
~weak_ptr()//清理sp2._prev
        {   // release resource
        this->_Decwref();
        }
void _Decwref()/sp2->prev._Rep不为0(即就是sp1的引用计数空间存在)
        {   // decrement weak reference count
        if (_Rep != 0)/
            _Rep->_Decwref();
        }
void _Decwref()//sp2->prev._Weaks从2减为1(即就是将sp1._Weaks减为1)
        {   // decrement weak reference count
        if (_MT_DECR(_Mtx, _Weaks) == 0)
            _Delete_this();//不执行
        }
调用operator delete释放节点sp2的空间
void _Decwref()//释放sp2引用计数空间
        {   // decrement weak reference count
        if (_MT_DECR(_Mtx, _Weaks) == 0)//sp2._weaks从2减为1
            _Delete_this();//不执行(也就是没有释放sp2的引用计数)
        }
----------------------------------------------------------------------------
析构sp1
~shared_ptr()
        {   // release resource
        this->_Decref();
        }
void _Decref()//减sp1的引用计数
        {   // decrement reference count
        if (_Rep != 0)//sp1._Rep不为0(sp1的引用计数不为空)
            _Rep->_Decref();m
        }
void _Decref()
        {   // decrement use count
        if (_MT_DECR(_Mtx, _Uses) == 0)//sp1._uses从1减为0
            {   // destroy managed resource, decrement weak reference count
            _Destroy();//释放节点空间
            _Decwref();//释放sp1的引用计数
            }
        }
-------------------------------------------------------------------------------
清理sp1节点内资源
virtual void _Destroy()
        {   // destroy managed resource
        delete _Ptr;//释放sp1节点的空间(需要去清理节点内的资源(包括sp1->_next和sp1->_prev))
        }
~weak_ptr()//清理sp1->next
        {   // release resource
        this->_Decwref();
        }
void _Decwref()
        {   // decrement weak reference count
        if (_MT_DECR(_Mtx, _Weaks) == 0)//sp1->next._weaks从1减为0(即就是sp2._weaks减为0)
            _Delete_this();//执行
        }
virtual void _Delete_this()//释放了sp1->_next._Rep空间(即就是sp2的引用计数空间)
        {   // destroy self
        delete this;
        }
~weak_ptr()//清理sp1._prev
        {   // release resource
        this->_Decwref();
        }
void _Decwref()
        {   // decrement weak reference count
        if (_Rep != 0)//sp1->_prev._Rep为空
            _Rep->_Decwref();//不执行
        }
调用operator delete释放节点sp1空间
-----------------------------------------------------------------------------------------------------------
释放sp1引用计数空间
void _Decwref()
        {   // decrement weak reference count
        if (_MT_DECR(_Mtx, _Weaks) == 0)//sp1._weaks从1减为0
            _Delete_this();
        }

virtual void _Delete_this()//释放sp1引用计数的空间
        {   // destroy self
        delete this;
        }

分析不同之处:
1)执行下面两条语句
sp1->_next = sp2;
 sp2->_prev = sp1;
都是将对方的_weaks加至2

2)释放节点空间(关注uses的大小,若可以减为0,则释放节点空间)
释放引用计数空间(关注_weaks的大小,若可以减为0,则释放引用计数的空间)
从而解决了循环引用的问题。

下面用图简单说明下析构过程:

sp2的析构过程:




sp1的析构过程:


对于c++标准库里shared_ptr和weak_ptr的继承关系简单图示:





总结:

在以下情况时使用 shared_ptr :
  • 当有多个使用者使用同一个对象,而没有一个明显的拥有者时

  • 当要把指针存入标准库容器时

  • 当要传送对象到库或从库获取对象,而没有明确的所有权时

  • 当管理一些需要特殊清除方式的资源时

    通过定制删除器的帮助。



由于看的源码太少,所以文中对于源码的理解不到位的地方还请各位大神指正!


已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页