shared_ptr探究

boost库下shared_ptr的源码

shared_ptr类

构造函数

拷贝构造函数

赋值语句

私有成员

boost库里的shared_ptr不太容易理解，这时候我模拟实现了一下它

#include <thread>
#include <mutex>

template <class T>
class SharedPtr
{
public:
	 SharedPtr(T* ptr = nullptr)
	 	: _ptr(ptr)
	 	, _pRefCount(new int(1))
		, _pMutex(new mutex)
	 {}
	 
	~SharedPtr() 
	{
		Release();
	}
	
	SharedPtr(const SharedPtr<T>& sp)
		: _ptr(sp._ptr)
		, _pRefCount(sp._pRefCount)
		, _pMutex(sp._pMutex)
	{
		AddRefCount();
	}
 	// sp1 = sp2
	 SharedPtr<T>& operator=(const SharedPtr<T>& sp)
 	{
 		//if (this != &sp)
 		if (_ptr != sp._ptr)
 		{
	 		// 释放管理的旧资源
			Release();
	  		// 共享管理新对象的资源，并增加引用计数
	 		_ptr = sp._ptr;
	 		_pRefCount = sp._pRefCount;
	 		_pMutex = sp._pMutex;
	 
		 	AddRefCount();
		 }
		 return *this;
	}
	 T& operator*() {return *_ptr;}
	 T* operator->() {return _ptr;}
	 int UseCount() {return *_pRefCount;}
	 T* Get() { return _ptr; }
	 void AddRefCount()
	 {
		 // 加锁或者使用加1的原子操作
		 _pMutex->lock();
		 ++(*_pRefCount);
		
		 _pMutex->unlock();
 	}
private:
	 void Release()
	 {
		 bool deleteflag = false;
	 
		 // 引用计数减1，如果减到0，则释放资源
		 _pMutex.lock();
		 if (--(*_pRefCount) == 0)
		 {
			 delete _ptr;
			 delete _pRefCount;
			 deleteflag = true;
		 }
		 _pMutex.unlock();
	 
		 if(deleteflag == true)
		 delete _pMutex;
	 }
private:
	 int* _pRefCount; // 引用计数
	 T* _ptr; // 指向管理资源的指针 
	 mutex* _pMutex; // 互斥锁
}

shared_ptr的原理是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

引用计数特点：

1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

shared_ptr的线程安全问题

1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或- -，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的。
2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

循环引用分析

struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
 	~ListNode(){ cout << "~ListNode()" << endl; }
};
int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	
	node1->_next = node2;
	node2->_prev = node1;
	
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0; 
 }

1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
4. 也就是说_next析构了，node2就释放了。
5. 也就是说_prev析构了，node1就释放了。
6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放

所以，解决shared_ptr的方法就是在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了

原理就是node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数

struct ListNode
{
	int _data;
	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;
	~ListNode()
	{ 
		cout << "~ListNode()" << endl; 
	}
};