Cpp || shared_ptr 模拟实现(线程安全相关)

最新推荐文章于 2024-07-30 04:00:00 发布
最新推荐文章于 2024-07-30 04:00:00 发布
阅读量483 收藏 1
点赞数
分类专栏： Cpp进阶学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jack_wang128801/article/details/105319815
版权

文章目录

shared_ptr模拟实现

  • 代码实现
#include<iostream>
#include<thread>
#include<mutex>

using namespace std; 


template<class T>
class Shared_Ptr{
  public:
    Shared_Ptr(T* ptr=nullptr)
      :_ptr(ptr)
       ,_UseCount(new int(1))
       ,_mut(new mutex)
  {

  }

    ~Shared_Ptr(){
      Release();
    }

    Shared_Ptr(const Shared_Ptr<T>& sp)
      :_ptr(sp._ptr)
       ,_UseCount(sp._UseCount)
       ,_mut(sp._mut)
  {
    Add_UseCount();
  }

    Shared_Ptr<T>& operator=(const Shared_Ptr<T>& sp){
      if(_ptr!=sp._ptr){
        //释放管理的旧的资源
        Release();
        //共享管理对象的资源,并增加引用计数
        _ptr=sp._ptr;
        _UseCount=sp._UseCount;
        _mut=sp._mut;

        Add_UseCount();
      }
      return *this;
    }

    T& operator*(){
      return *_ptr;
    }

    T* operator->(){
      return _ptr;
    }
    void Add_UseCount(){
      //加锁或者使用加1的原子操作
      _mut->lock();
      ++(*_UseCount);
      _mut->unlock();
    }
 
    int UseCount(){
      return *_UseCount;
    }

  private:
    void Release(){
      //用于控制引用计数
     bool deleteFalg=false;

     _mut->lock();

     if(--(*_UseCount)==0){
       delete _ptr;
       delete _UseCount;
       deleteFalg=true;
     }
     _mut->unlock();

     if(deleteFalg==true){
       delete _mut;
     }
    }
  private:
    T* _ptr;
    int* _UseCount;
    mutex* _mut;
};

int main(){
  Shared_Ptr<int> sp(new int(10));
  Shared_Ptr<int> sp1(sp);
  *sp1=20;
  cout<<"sp.UseCount():"<<sp.UseCount()<<endl;
  cout<<"sp1.UseCount():"<<sp1.UseCount()<<endl;
 
  Shared_Ptr<int> sp2(new int(10));
  sp1=sp2;
  cout<<"sp.UseCount():"<<sp.UseCount()<<endl;
  cout<<"sp1.UseCount():"<<sp1.UseCount()<<endl;
  cout<<"sp2.UseCount():"<<sp2.UseCount()<<endl;

  sp=sp2;

  cout<<"sp.UseCount():"<<sp.UseCount()<<endl;
  cout<<"sp1.UseCount():"<<sp1.UseCount()<<endl;
  cout<<"sp2.UseCount():"<<sp2.UseCount()<<endl;

  return 0;
}
  • 运行结果

在这里插入图片描述

std::shared_ptr 的线程安全问题

  • std::shared_ptr的线程安全问题
  • 通过下面的程序我们来测试shared_ptr的线程安全问题。需要注意的是shared_ptr的线程安全分为两方面：
  • 1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的。
  • 2.智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。
线程安全版本的shared_ptr使用
#include<iostream>
#include<thread>
#include<mutex>

using namespace std;

mutex mux;

struct Date{
  int _year=1;
  int _month=1;
  int _day=1;

  ~Date(){
    cout<<"~Date()"<<endl;
  }
};
template<class T>
class Shared_Ptr{

  private:
    T* _Ptr;
    int *_UseCount;
    mutex *_Mux;

  public:
    Shared_Ptr(T* ptr)
      :_Ptr(ptr)
       ,_UseCount(new int(1))
       ,_Mux(new mutex)
  {

  }

    Shared_Ptr(const Shared_Ptr<T>& sp)
      :_Ptr(sp._Ptr)
       ,_UseCount(sp._UseCount)
       ,_Mux(sp._Mux)
  {
    addRef();
  }

    int addRef(){
      _Mux->lock();
      ++(*_UseCount);
      _Mux->unlock();
      return *_UseCount;
    }

    Shared_Ptr<T>& operator=(const Shared_Ptr<T>& sp){
      if(_Ptr!=sp._Ptr){
        if(subRef()==0){
          delete _Ptr;
          delete _UseCount;
          delete _Mux;
          _Ptr=nullptr;
          _UseCount=nullptr;
          _Mux=nullptr;
        }
        _Ptr=sp._Ptr;
        _UseCount=sp._UseCount;
        _Mux=sp._Mux;
      }
      return *this;
    }
    int subRef(){
      _Mux->lock();
      --(*_UseCount);
      _Mux->unlock();
      return *_UseCount;
    }

    ~Shared_Ptr(){
      if(subRef()==0){
        delete _Ptr;
        delete _UseCount;
        delete _Mux;
        _Mux=nullptr;
        _UseCount=nullptr;
        _Ptr=nullptr;
      }
    }

    T& operator*(){
      return *_Ptr;
    }

    T* operator->(){
      return _Ptr;
    }

    int UseCount(){
      return *_UseCount;
    }
};


Shared_Ptr<Date> sp(new Date);

void Test(){

  for(size_t i=0;i<1000;i++){
    Shared_Ptr<Date> p(sp);
    mux.lock();
    
    p->_year++;
    p->_month++;
    p->_day++;
    mux.unlock();
  }

}


int main(){

  thread t1(Test);
  thread t2(Test);

  t1.join();
  t2.join();
  
   cout<<sp->_year<<endl;
   cout<<sp->_month<<endl;
   cout<<sp->_day<<endl;
  return 0;
}
  • 运行结果

在这里插入图片描述

线程不安全版本
#include<iostream>
#include<thread>
#include<mutex>

using namespace std;

mutex mux;

struct Date{
  int _year=1;
  int _month=1;
  int _day=1;

  ~Date(){
    cout<<"~Date()"<<endl;
  }
};
template<class T>
class Shared_Ptr{

  private:
    T* _Ptr;
    int *_UseCount;
    mutex *_Mux;

  public:
    Shared_Ptr(T* ptr)
      :_Ptr(ptr)
       ,_UseCount(new int(1))
       ,_Mux(new mutex)
  {

  }

    Shared_Ptr(const Shared_Ptr<T>& sp)
      :_Ptr(sp._Ptr)
       ,_UseCount(sp._UseCount)
       ,_Mux(sp._Mux)
  {
    addRef();
  }

    int addRef(){
      _Mux->lock();
      ++(*_UseCount);
      _Mux->unlock();
      return *_UseCount;
    }

    Shared_Ptr<T>& operator=(const Shared_Ptr<T>& sp){
      if(_Ptr!=sp._Ptr){
        if(subRef()==0){
          delete _Ptr;
          delete _UseCount;
          delete _Mux;
          _Ptr=nullptr;
          _UseCount=nullptr;
          _Mux=nullptr;
        }
        _Ptr=sp._Ptr;
        _UseCount=sp._UseCount;
        _Mux=sp._Mux;
      }
      return *this;
    }
    int subRef(){
      _Mux->lock();
      --(*_UseCount);
      _Mux->unlock();
      return *_UseCount;
    }

    ~Shared_Ptr(){
      if(subRef()==0){
        delete _Ptr;
        delete _UseCount;
        delete _Mux;
        _Mux=nullptr;
        _UseCount=nullptr;
        _Ptr=nullptr;
      }
    }

    T& operator*(){
      return *_Ptr;
    }

    T* operator->(){
      return _Ptr;
    }

    int UseCount(){
      return *_UseCount;
    }
};


Shared_Ptr<Date> sp(new Date);

void Test(){

  for(size_t i=0;i<1000;i++){
    Shared_Ptr<Date> p(sp);
    //mux.lock();
    
    p->_year++;
    p->_month++;
    p->_day++;
    //mux.unlock();
  }

}


int main(){

  thread t1(Test);
  thread t2(Test);

  t1.join();
  t2.join();
  
   cout<<sp->_year<<endl;
   cout<<sp->_month<<endl;
   cout<<sp->_day<<endl;
  return 0;
}
  • 运行结果

在这里插入图片描述

可以看到去掉安全锁之后,每次的运行结果都是不同的.这就是两个线程抢占式执行的结果

std::shared_ptr 的循环引用

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成员，所以这就叫循环引用，谁也不会释放

在这里插入图片描述

  • 解决方案
// 解决方案：在引用计数的场景下，把节点中的_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;} 
};
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; 
 }
  • 如果不是new出来的对象如何通过智能指针管理呢?其实shared_ptr设计了一个删除器来解决这个问题.
  • 仿函数的删除器
// 仿函数的删除器
template<class T>
struct FreeFunc {
 void operator()(T* ptr)
 {
 cout << "free:" << ptr << endl;
 free(ptr);
 }
};
template<class T>
struct DeleteArrayFunc {
 void operator()(T* ptr)
 { 
 cout << "delete[]" << ptr << endl;
 delete[] ptr; 
 }
};
int main()
{
 FreeFunc<int> freeFunc;
 shared_ptr<int> sp1((int*)malloc(4), freeFunc);
 DeleteArrayFunc<int> deleteArrayFunc;
 shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);
 
 return 0; 
}

C++11和boost中智能指针的关系

  • 1.C++ 98 中产生了第一个智能指针auto_ptr.
  • 2.C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
  • 3.C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
  • 4.C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的
    scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

RAII扩展学习

  • RAII思想除了可以用来设计智能指针，还可以用来设计守卫锁，防止异常安全导致的死锁问题。
  • 守卫锁：利用RAII思想解决线程死锁，构造函数中加锁，析构函数中解锁，防止死锁的形成和资源的管理
#include <thread>
#include <mutex>
// C++11的库中也有一个lock_guard，下面的LockGuard造轮子其实就是为了学习他的原理
template<class Mutex>
class LockGuard
{
public:
 LockGuard(Mutex& mtx)
 :_mutex(mtx)
 {
 _mutex.lock();
 }
 ~LockGuard()
 {
 _mutex.unlock();
 }
 LockGuard(const LockGuard<Mutex>&) = delete;
private:
 // 注意这里必须使用引用，否则锁的就不是一个互斥量对象
 Mutex& _mutex;
};
mutex mtx;
static int n = 0;
void Func()
{
 for (size_t i = 0; i < 1000000; ++i)
 {
 LockGuard<mutex> lock(mtx);
 ++n;
 }
}

int main()
{
 int begin = clock();
 thread t1(Func);
 thread t2(Func);
 t1.join();
 t2.join();
 int end = clock();
 cout << n << endl;
 cout <<"cost time:" <<end - begin << endl;
 
 return 0; 
 }
iTXCode
关注
专栏目录
深入理解Modern C++智能指针std::shared_ptr
qls315的博客
06-02 2235
现代C++为了解决内存泄露以及资源回收等问题，引入了智能指针的概念。在日常的C++实践中也是高频使用。本文是在实践过程中，对现代C++中的智能指针进行的一个稍微全面的总结。本文主要讲解std::shared_ptr的相关内容。std::shared_ptr也即智能指针，采用RAII手法，是一个模版对象。std::shared_ptr表示某一个资源的共享所有权。可以通过如下两种方式创建std::shared_ptr对象 2 实现原理 此处以如下代码为例，讲解std::shared_ptr的实现原理
shared_ptr线程安全性全面分析
09-05
正如boost文档所宣称的，boost为shared_ptr提供了与内置类型同级别的线程安全性。这包括：1. 同一个shared_ptr对象可以被多线程同时读取。2. 不同的shared_ptr对象可以被多线程同时修改成
Cpp / shared_ptr
布袋和尚
11-10 399
1、诞生原因 在 C++ 中，一大缺陷是给定一个非空指针，程序并不能确定该指针指向的内存是否正常，即：是否已经被释放掉。 为了解决上述问题，boost 库中诞生了 shared_ptr 智能指针。 2、核心思想 shared_ptr 智能指针设计的核心思想是对内存块采用引用计数的方式进行内存回收，每增加一个 shared_ptr 对该内存块的指向，则引用计数 + 1，否则 - 1，当引用计数为 0 时则 delete 该内存块。 3、栗子 #include <iostream> #
【C++】std::shared_ptr智能指针详解和示例
不定时分享，互相学习，共同进步
07-30 1053
在C++中，智能指针是一种用于自动管理动态分配内存的机制，旨在减少内存泄漏和野指针的风险。std::shared_ptr 是C++标准库提供的几种智能指针之一，它通过共享所有权的机制来管理动态分配的对象。本文将详细解析 std::shared_ptr 的工作原理、特性，并通过一个应用案例来展示其在实际开发中的使用。
C++之shared_ptr总结
u013696062的专栏
09-29 3万+
C++关于shared_ptr的总结。里面有一份简单的源码实现，有助于理解shared_ptr的实际原理。希望对大家有帮助。也欢迎批评指正。
shared_ptr:线程安全、循环引用
liuxuejiang158的专栏
10-23 3150
shared_ptr用来管理堆对象可以避免delete，但是注意shared_ptr本身是个对象因此其的声明周期、shared_ptr对象的读写操作非原子化那么在多线程环境下仍然存在很多问题，即shared_ptr对象本身的线程安全级别非100%。在多线程中访问同一个shared_ptr对象应该用mutex保护。    shared_ptr使用不当会延长锁管理的对象(假设为A)的生命周期，即有什
C++11中shared_ptr的使用
热门推荐
网络资源是无限的
08-13 8万+
C++11中shared_ptr的使用
C++11 std::shared_ptr总结与使用示例代码详解
08-19
引用计数的加一/减一操作是原子性的，因此是线程安全的。 三、make_shared的优点 make_shared要优于使用new，make_shared可以一次将需要内存分配好。例如： std::shared_ptr<Test> p = std::make_shared(); std::...
Modern C++ std::shared_ptr的实现原理
老宅的虚拟空间
01-26 1910
shared_ptr的实现原理
C++11 智能指针之shared_ptr代码详解
08-19
make_shared函数会在堆上分配内存，初始化对象，并返回一个指向该对象的shared_ptr，这种方式是线程安全的，并且能够优化内存分配，因为它是将控制块和对象的存储空间分配在同一个内存块中。例如： ```cpp shared_...
C++智能指针shared_ptr分析
08-31
其中，`shared_ptr`是C++标准库中的一个智能指针类型，它实现了引用计数机制，广泛应用于多线程环境和复杂对象所有权共享的场景。 **一、shared_ptr概述** `shared_ptr`是C++智能指针中功能最为强大的一种，它通过...
C++实现一个线程安全版本的shared_ptr（以及如何设置删除器）
小白的Coding之旅
12-01 334
#include<iostream> #include<mutex> #include<thread> using namespace std; namespace LMJian { //设置删除器 template<class T> class DFDef { public: void operator()(T*& _ptr)...
推荐cpp的shared_ptr和auto_ptr的文章
逐梦如风-毕康
11-09 516
cpp的shared_ptr和auto_ptr的文章http://blog.csdn.net/u013696062/article/details/39665247http://blog.csdn.net/u013696062/article/details/39477571
shared_ptr的线程安全
weixin_43606861的博客
04-25 3483
文章目录1. shared_ptr的线程安全2. shared_ptr 的数据结构3. 多线程无保护读写 shared_ptr 可能出现的 race condition 1. shared_ptr的线程安全 shared_ptr 的引用计数本身是安全且无锁的，但对象的读写则不是，因为 shared_ptr 有两个数据成员，读写操作不能原子化。根据文档（http://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm#ThreadSafet
shared_ptr 线程安全
wuxiaoyu0806的博客
07-07 204
对象都被销毁或重置时，对象的引用计数才会归零，从而触发对象的析构函数调用，释放对象所占用的资源。的引用计数是线程安全的。对象如果互相指向同一个对象，它们的引用计数永远不会为零，这是因为每个。指向某个对象时，该对象都不会被提前释放，直到所有相关的。对象内部维护一个计数器（引用计数），用于跟踪有多少个。复制构造函数或赋值操作后，引用计数增加到 2。所指向的对象时，需要额外的同步机制来确保线程安全。只有当所有指向该对象的。它们的引用计数在创建时为 1，当。因为shared_ptr。具体来说，如果有两个。
shared_ptr 的线程安全性
wjiaman
05-06 4666
多线程环境下，调用不同的 shared_ptr 实例的成员函数是不需要额外的同步手段的，即使这些 shared_ptr 管理的是相同的对象。多线程对于同一个 shared_ptr 实例的读操作（访问）可以保证线程安全；但对于同一个 shared_ptr 实例的写操作（改变一个 shared_ptr 指向的对象）则需要同步，否则会发生 race condition。即多个线程可以同时读取一个 shared_ptr 对象；多个线程同时读写一个 shared_ptr 对象，则需要加锁。
shared_ptr线程安全性
开心乐源的专栏
01-24 1314
Thread Safety shared_ptr objects offer the same level of thread safety as built-in types. A shared_ptr instance can be "read" (accessed using only const operations) simultaneously by multiple thr
shared_ptr的线程安全性
diaolingle的专栏
05-11 480
shared_ptr 的线程安全级别和内建类型、标准库容器、std::string 一样，即： • 一个 shared_ptr 对象实体可被多个线程同时读取； • 两个 shared_ptr 对象实体可以被两个线程同时写入，“析构”算写操作； • 如果要从多个线程读写同一个 shared_ptr 对象，那么需要加锁； 请注意，以上是 shared_ptr 对象本身的线程安全
使用shared_ptr 创建线程
最新发布
09-21
创建一个 `shared_ptr` 线程并不是直接操作线程，而是通过将对象包装在 `shared_ptr` 中，然后在线程中使用这个对象。以下是一个简单的例子： ```cpp #include #include // 假设有一个类 MyClass class MyClass ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值