从零简单实现一个线程安全的C++共享指针(shared_ptr)

已于 2024-05-13 22:10:48 修改
阅读量680 收藏 6
点赞数 10
文章标签： c++ 开发语言
于 2024-03-23 12:18:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36653924/article/details/136963081
版权
本文详细介绍了C++中的共享指针shared_ptr的工作原理，包括引用计数机制、复制构造函数、析构函数以及在多线程环境下的线程安全改进，通过实例展示了如何创建和管理对象生命周期。
摘要由CSDN通过智能技术生成

共享指针原理：

shared_ptr主要是用来自动管理动态创建对象的销毁，记录对象被引用的次数，当引用计数清零的时候，把指向的内存区域自动释放掉

如果要手动实现一个共享指针的话就需要一个共享指针类，类中存着被指向的对象的指针

当对象被多个共享指针指向的时候，就需要一个共享的引用计数器counter

当对象被共享指针指向的时候，引用计数器为2

当一个共享指针被释放后，引用计数器的值减1

当都断的时候，引用计数器变为0，这时候清理对象A

共享指针计数器：

class Counter
{
public:
	Counter()
	{
		count = 1;	
	}
	
	void add()
	{
		count++;
	}
	
	void sub()
	{
		count--;
	}
	
	int get() const
	{
		return count;
	}
	
private:
	int count;
};

 共享指针类：

template <typename T>
class Sp
{
public:
	Sp();                           //默认构造函数
	~Sp();                          //析构函数
	Sp(T *ptr);                     //参数构造函数
	Sp(const Sp &obj);              //复制构造函数
	Sp &operator=(const Sp &obj);   //重载=
	T *get();                       //得到共享指针指向的类
	   
	int getcount();                 //得到引用计数器
private:
	
	T *my_ptr;                      //共享指针所指向的对象
	Counter* counter;                   //引用计数器
	void clear();                   //清理函数
};

//默认构造函数，参数为空，构造一个引用计数器
template<typename T>
Sp<T>::Sp()
{
	my_ptr = nullptr;
	counter = new Counter();
}

//复制构造函数，新的共享指针指向旧的共享指针所指对象
template<typename T>
Sp<T>::Sp(const Sp &obj)
{
    //将所指对象也变为目标所指的对象
	my_ptr = obj.my_ptr;
    //获取引用计数器，使得两个共享指针用一个引用计数器
	counter = obj.counter;
    //使这个对象的引用计数器+1
	counter->add();	
};

//重载=
template<typename T>
Sp<T> &Sp<T>::operator=(const Sp&obj)
{
    //清理当前所引用对象和引用计数器
	clear();
    //指向新的对象，并获取目标对象的引用计数器
	my_ptr = obj.my_ptr;
	counter = obj.counter;
    //引用计数器+1
	counter->add();
    //返回自己
	return *this;	
}

//创建一个共享指针指向目标类，构造一个新的引用计数器
template<typename T>
Sp<T>::Sp(T *ptr)
{
	my_ptr = ptr;
	counter = new Counter();
}

//析构函数，出作用域的时候，调用清理函数
template<typename T>
Sp<T>:: ~Sp()
{
	clear();
}

//清理函数，调用时将引用计数器的值减1，若减为0，清理指向的对象内存区域
template<typename T>
void Sp<T>::clear()
{
    //引用计数器-1 
	counter->sub();
    //如果引用计数器变为0，清理对象
	if(0 == counter->get())
	{
		if(my_ptr)
		{
			delete my_ptr;
		}
		delete counter;
	}
}

//当前共享指针指向的对象，被几个共享指针所引用
template<typename T>
int Sp<T>::getcount()
{
	return counter->get();	
};

class A{
public:
	A()
	{
		cout<<"A construct!"<<endl;
	};
	~A()
	{
		cout<<"A destruct!"<<endl;
	};
};

构造测试对象A：

class A{
public:
	A()
	{
		cout<<"A construct!"<<endl;
	};
	~A()
	{
		cout<<"A destruct!"<<endl;
	};
};

测试函数：

int main()
{
	cout<<"start"<<endl;
    { 
      	//创建共享指针sp指向新创建的对象A 
	    Sp<A> sp(new A);
        cout<<sp.getcount()<<endl;
	    {
	  		//创建共享指针sp2指向A，这时有两个共享指针指向A
	    	Sp<A> sp2 = sp;
            cout<<sp.getcount()<<endl;
		}
	    cout<<sp.getcount()<<endl;
	}
    //出了作用域后，引用计数器-1，此时对象被析构，内存被回收
    cout<<"over"<<endl;
}

 输出结果：

这时候，如果多个线程都在使用这个引用计数器的时候，容易引发多线程安全问题，所以在这里添加互斥锁

为计数器类添加线程安全保障

class Counter
{
public:
	Counter()
	{
		my_Mutex = new mutex;
		count = 1;	
	}
	
	void add()
	{
		my_Mutex->lock();
		count++;
		my_Mutex->unlock();
	}
	
	void sub()
	{
		my_Mutex->lock();
		count--;
		my_Mutex->unlock();
	}
	
	int get() const
	{
		return count;
	}
	
private:
	mutex* my_Mutex;
	int count;
};

使用原子变量实现多线程安全保障

count使用原子变量来实现线程安全

class Counter
{
public:
	Counter()
	{
		count = 1;	
	}
	
	void add()
	{
		count++;
	}
	
	void sub()
	{
		count--;
	}
	
	int get() const
	{
		return count;
	}
	
private:
	std::atomic<int> count;
};

全部代码：

#include<iostream>
#include<atomic>

using namespace std;

class Counter
{
public:
	Counter()
	{
		count = 1;	
	}
	
	void add()
	{
		count++;
	}
	
	void sub()
	{
		count--;
	}
	
	int get() const
	{
		return count;
	}
	
private:
	std::atomic<int> count;
};

template <typename T>
class Sp
{
public:
	Sp();                           //默认构造函数
	Sp(T *ptr);                     //参数构造函数
	Sp(const Sp &obj);              //复制构造函数
	~Sp();                          //析构函数
	Sp &operator=(const Sp &obj);   //重载=
	T *get();                       //得到共享指针指向的类
	   
	int getcount();                 //得到引用计数器
private:
	T *my_ptr;                      //共享指针所指向的对象
	Counter* counter;                   //引用计数器
	void clear();                   //清理函数
};

//默认构造函数，参数为空，构造一个引用计数器
template<typename T>
Sp<T>::Sp()
{
	my_ptr = nullptr;
	counter = new Counter();
	counter->add();
}

//复制构造函数，新的共享指针指向旧的共享指针所指对象
template<typename T>
Sp<T>::Sp(const Sp &obj)
{
    //将所指对象也变为目标所指的对象
	my_ptr = obj.my_ptr;
    //获取引用计数器，使得两个共享指针用一个引用计数器
	counter = obj.counter;
    //使这个对象的引用计数器+1
	counter->add();	
};

//重载=
template<typename T>
Sp<T> &Sp<T>::operator=(const Sp&obj)
{
    //清理当前所引用对象和引用计数器
	clear();
    //指向新的对象，并获取目标对象的引用计数器
	my_ptr = obj.my_ptr;
	counter = obj.counter;
    //引用计数器+1
	counter->add();
    //返回自己
	return *this;	
}

//创建一个共享指针指向目标类，构造一个新的引用计数器
template<typename T>
Sp<T>::Sp(T *ptr)
{
	my_ptr = ptr;
	counter = new Counter();
}

//析构函数，出作用域的时候，调用清理函数
template<typename T>
Sp<T>:: ~Sp()
{
	clear();
}

//清理函数，调用时将引用计数器的值减1，若减为0，清理指向的对象内存区域
template<typename T>
void Sp<T>::clear()
{
    //引用计数器-1 
	counter->sub();
    //如果引用计数器变为0，清理对象
	if(0 == counter->get())
	{
		if(my_ptr)
		{
			delete my_ptr;
		}
		delete counter;
	}
}

//当前共享指针指向的对象，被几个共享指针所引用
template<typename T>
int Sp<T>::getcount()
{
	return counter->get();	
};

class A{
public:
	A()
	{
		cout<<"A construct!"<<endl;
	};
	~A()
	{
		cout<<"A destruct!"<<endl;
	};
};


int main()
{
	cout<<"start"<<endl;
    { 
      	//创建共享指针sp指向新创建的对象A 
	    Sp<A> sp(new A);
        cout<<sp.getcount()<<endl;
	    {
	  		//创建共享指针sp2指向A，这时有两个共享指针指向A
	    	Sp<A> sp2 = sp;
            cout<<sp.getcount()<<endl;
		}
	    cout<<sp.getcount()<<endl;
	}
    //出了作用域后，引用计数器-1，此时对象被析构
    cout<<"over"<<endl;
}

星空_MAX
关注
  • 10
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
shared_ptr线程安全性全面分析
09-05
正如boost文档所宣称的，boost为shared_ptr提供了与内置类型同级别的线程安全性。这包括：1. 同一个shared_ptr对象可以被多线程同时读取。2. 不同的shared_ptr对象可以被多线程同时修改成
C++智能指针shared_ptr分析
08-31
其中，`shared_ptr`是C++标准库中的一个智能指针类型，它实现了引用计数机制，广泛应用于多线程环境和复杂对象所有权共享的场景。 **一、shared_ptr概述** `shared_ptr`是C++智能指针中功能最为强大的一种，它通过...
【14】c++11新特性 —＞共享智能指针
weixin_42097108的博客
11-07 221
在C++中没有垃圾回收机制，必须自己释放分配的内存，否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针（smart pointer）。。
C++: shared_ptr是线程安全的吗
最新发布
wsqiangz的博客
06-10 492
对shared_ptr进行并发拷贝，对数据指针和控制块指针仅进行读取并复制，然后对引用计数进行递增，而引用计数增加是原子操作。因此是线程安全的。
shared_ptr的安全性
qq_43287763的博客
03-10 1263
你可以试图通过调用`lock()`方法来将`weak_ptr`提升为`shared_ptr`，如果所监视的对象还活着（即引用计数大于0），`lock()`会成功返回一个有效的`shared_ptr`，否则返回一个空的`shared_ptr`。4. 将 `a` 赋值给 `b->a_ptr`，但由于 `b->a_ptr` 是 `std::weak_ptr`，它并不增加 `A` 实例的引用计数，所以 `A` 的引用计数仍然是1。使用`weak_ptr`可以避免这种情况，因为`weak_ptr`不增加引用计数。
C++ shared_ptr的线程安全性
GreatTang的博客
07-17 3955
C++ shared_ptr的线程安全性
shared_ptr的线程安全性
D_Guco的专栏
05-01 9922
    shared_ptr的出现在某种程度上解放了c++程序员，c++11标准原生的支持了并发编程，在并发编程中shared_ptr的线程安全问题如何保证呢？先撇开shared_ptr对象的线程安全性，先看shared_ptr本身的线程安全问题。    我们知道，shared_ptr的底层实现原理是引用计数，关于这个计数是否线程安全呢，如果我们把shared_ptr分别传递到不同的线程中，是否会...
C++自定义实现共享指针shared_ptr
qq_43461982的博客
09-23 192
public:~stu() {}cout
【C++】shared_ptr线程安全问题和循环引用问题
qq_42270373的博客
06-12 924
看下面的代码我们就会发现shared_ptr在多线程的情况下会出问题： void test_multi_thread_copy(yan::shared_ptr<int>& sp,size_t n)//把智能指针拷贝n次 { for (size_t i = 0; i < n; i++) { yan::shared_ptr<int> copy(sp)...
浅析Boost智能指针:scoped_ptr shared_ptr weak_ptr
09-05
`boost::shared_ptr` 是一个可共享所有权的智能指针，多个`boost::shared_ptr`可以共享同一个对象，当最后一个`boost::shared_ptr`析构时，对象也会被销毁。这通常用于需要多线程环境下的资源管理。 #### 特点： 1....
智能指针shared_ptr的Demo
06-14
在这个“智能指针shared_ptr的Demo”中，我们将深入探讨`shared_ptr`的用法和特点。 `shared_ptr`的主要功能是自动管理内存，当最后一个`shared_ptr`实例被销毁时，它会自动调用所指向对象的析构函数，从而释放内存...
C++智能指针shared-ptr讲解与使用.pdf
02-27
其中，`shared_ptr`是C++标准库提供的一个关键智能指针类型，它实现了共享所有权的概念。 在传统的C++编程中，程序员需要手动使用`new`来分配内存，然后用`delete`来释放内存。然而，随着代码规模的增长，忘记释放...
C++ shared_ptr的线程安全问题
weixin_43850474的博客
05-25 3101
shared_ptr的线程安全问题 首先看看下面的图，这个图描述的就是对象、资源、引用计数之间的关系。 shared_ptr的线程安全问题需要从两个角度来分析： （1）从引用计数的角度来看： 虽然引用计数存在于每一个shared_ptr对象中，但是实际上它是要跟随对象所管理的资源。引用计数会随着指向这块资源的shared_ptr对象的增加而增加。因此引用计数是要指向同一块资源的所有的对象共享的，所以实际上引用计数在shared_ptr底层中是以指针的形式实现的，所有的对象通过指针访问同一块空间，从而实现共
C++智能指针shared_ptr用法
weixin_40355471的博客
12-03 8544
C++，shared_ptr对象管理指针,shared_ptr提供的接口, shared_ptr初始化,构造函数初始化,std::make_shared 初始化,reset初始化,shared_ptr管理指针的构造和析构,shared_ptr获取原始指针,shared_ptr的线程安全,shared_ptr应用之enable_shared_from_this.
C++——智能指针——auto_ptr、shared_ptr、unique_ptr
勿在浮沙築高台
04-29 845
1.4、智能指针 智能指针是行为类似于指针的类对象。 C++11 中提供了三种智能指针，使用这些智能指针时需要引用头文件 ： ·shared_ptr; ·unique_ptr; ·auto_ptr; 这三个智能指针模板都定义了类似指针的对象，可意义将new获得（直接或者间接）的地址赋给这种对象。当智能指针过期时，其析构函数将使delete来释放内存。智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。 ·weak_ptr;
【C++11】智能指针
学了就忘是正常现象
04-22 679
unique_ptr:唯一指针，类内部禁用拷贝构造和赋值运算符重载； shared_ptr:共享指针，采用计数的方式，计数器为零自动析构资源，死穴：循环引用 weak_ptr:解决shared_ptr循环引用问题，本身不参与资源的管理，不对资源计数
C++智能指针、shared_ptr、enable_shared_from_this
泠山的博客
07-08 397
由于C++语言没有自动内存回收机制，程序员每次new出来的内存都要手动delete。程序员忘记delete，流程更太复杂，最终导致没有delete，异常导致程序过早退出，没有执行delete的情况并不罕见。用智能指针便可以有效缓解这类问题。std::auto_ptr(已被C++11摒弃)、std::unique_ptr、std::shared_ptr、std::weak_ptr。
c++ 智能指针用法详解
weixin_33980459的博客
12-03 820
本文介绍c++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被c++11弃用。 为什么要使用智能指针：我们知道c++的内存管理是让很多人头疼的事，当我们写一个new语句时，一般就会立即把delete语句直接也写了，但是我们不能避免程序还未执行到delete时就跳转了或者在函数中没有执行到最后的...
【C++】share_ptr详解
songbijian的博客
03-26 2878
分析：根据对象生成顺序，先初始化基类 enable_shared_from_this ，再初始化派生类 Frame 对象本身，这时 Frame 对象已经生成，但 _M_weak_this 成员还未被初始化，最后应通过 shared_ptr<T> sp(new T()) 等方式调用 shared_ptr 构造函数（内部会调用 _M_weak_assign 成员函数来初始化 _M_weak_this 成员）。share_ptr 内部中的引用计数是线程安全的，但是引用的资源不是线程安全的。
智能指针shared_ptr实现
09-14
由于shared_ptr是可以被多个指针共享的，因此在多线程环境中，可能存在多个线程同时操作同一个shared_ptr。为了避免竞争条件，shared_ptr内部使用了锁来保证多线程操作的原子性和线程安全性。 总结起来，shared_ptr...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值