shared_ptr 实现

最新推荐文章于 2023-05-06 10:47:58 发布

dodo_check

最新推荐文章于 2023-05-06 10:47:58 发布

阅读量2.7k

点赞数

分类专栏： boost

boost 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

前几天有个人问了我一个问题：如何将一个智能指针作为函数的返回值传递出来。当时这个问题一下子把我问倒了，后来经人提醒有一个叫shared_ptr的智能指针可以解决这个问题。

将shared_ptr作为函数返回值的代码是这样的：

 
   01#include <tr1/memory>
 
   02#include <stdio.h>
 
   03 
 
   04using std::tr1::shared_ptr;
 
   05 
 
   06 
 
   07shared_ptr<int> ReturnSharedPtr()
 
   08{
 
   09    shared_ptr<int> p(new int(1000));
 
   10    return p;
 
   11}
 
   12 
 
   13int main()
 
   14{
 
   15    shared_ptr<int> p1 = ReturnSharedPtr();
 
   16    printf("%d\n", *p1);
 
   17    return 0;
 
   18}

在g++4.3版本以上编译通过。shared_ptr头文件的位置有点古怪，在我的DEBIAN(squeeze）机器上的这个地方：/usr/include/c++/4.4/tr1/shared_ptr.h，所以使用时要

`1`	`#include <tr1/memory>`

而且shared_ptr被包装在std::tr1这个名字空间内。所以使用的时候和一般的stl模板的方式不大一样，要using std::tr1这个namespace。也可以用一个编译器选项去掉这种古怪的定义方法，具体是那个选项我查不到了。请了解的人帮忙指正一下。

shared_ptr的实现

看了一下stl的源码，shared_ptr的实现是这样的: shared_ptr模板类有一个__shared_count类型的成员_M_refcount来处理引用计数的问题。__shared_count也是一个模板类，它的内部有一个指向Sp_counted_base_impl类型的指针_M_pi。所有引用同一个对象的shared_ptr都共用一个_M_pi指针。

当一个shared_ptr拷贝复制时， _M_pi指针调用_M_add_ref_copy（）函数将引用计数+1。当shared_ptr析构时，_M_pi指针调用_M_release()函数将引用计数-1。 _M_release()函数中会判断引用计数是否为0. 如果引用计数为0，则将shared_ptr引用的对象内存释放掉。

 
   1__shared_count(const __shared_count& __r) 
 
   2      : _M_pi(__r._M_pi) // nothrow
 
   3      {     
 
   4    if (_M_pi != 0)
 
   5      _M_pi->_M_add_ref_copy();
 
   6      COSTA_DEBUG_REFCOUNT;
 
   7      }

这是__shared_count拷贝复制时的代码。首先将参数__r的_M_pi指针赋值给自己，然后判断指针是否为NULL，如果不为null 则增加引用计数。COSTA_DEBUG_REFCOUNT和COSTA_DEBUG_SHAREDPTR是我为了打印引用计数的调试代码，会打印文件行号和当前引用计数的值。

 
   1#define COSTA_DEBUG_REFCOUNT fprintf(stdout,"%s:%d costaxu debug refcount: %d\n", __FILE__,__LINE__,_M_pi->_M_get_use_count());
 
   2 
 
   3 
 
   4#define COSTA_DEBUG_SHAREDPTR fprintf(stdout,"%s:%d costaxu debug \n", __FILE__,__LINE__);

 
   01__shared_count&
 
   02      operator=(const __shared_count& __r) // nothrow
 
   03      {     
 
   04    _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 
   05    if (__tmp != _M_pi)
 
   06      {     
 
   07        if (__tmp != 0)
 
   08          __tmp->_M_add_ref_copy();
 
   09        if (_M_pi != 0)
 
   10          _M_pi->_M_release();
 
   11        _M_pi = __tmp;
 
   12      }
 
   13      COSTA_DEBUG_REFCOUNT;
 
   14    return *this;
 
   15      }

这是__share_count重载赋值操作符的代码。首先，判断等号左右两边的__share_count是否引用同一个对象。如果引用同一个对象(__tmp==_M_pi)，那么引用计数不变，什么都不用做。如果不是的话，就把等号左边的share_ptr的引用计数-1，将等号右边的引用计数+1 。例如：有两个shared_ptr p1和p2, 运行p1= p2 。假如p1和p2是引用同一个对象的，那么引用计数不变。如果p1和p2是指向不同对象的，那么p1所指向对象的引用计数-1， p2指向对象的引用计数+1。

 
   1~__shared_count() // nothrow
 
   2      {
 
   3    if (_M_pi != 0)
 
   4      _M_pi->_M_release();
 
   5 
 
   6      COSTA_DEBUG_REFCOUNT;
 
   7      }

上面是__share_count的析构函数，其实析构函数只是调用了_M_pi的_M_release这个成员函数。_M_release这个函数，除了会将引用计数-1之外，还会判断是否引用计数为0，如果为0就调用_M_dispose()函数。 _M_dispose函数会将share_ptr引用的对象释放内存。

 
   1virtual  void
 
   2      _M_dispose() // nothrow
 
   3      {
 
   4          COSTA_DEBUG_SHAREDPTR;
 
   5          _M_del(_M_ptr);
 
   6      }

_M_del是在构造_M_pi时候就初始化好的内存回收函数， _M_ptr就是shared_ptr引用的对象指针。

下面是我写的一段简单的测试代码:

 
   01#include <stdio.h>
 
   02#include <tr1/memory>
 
   03 
 
   04using std::tr1::shared_ptr;
 
   05 
 
   06 
 
   07shared_ptr<int> ReturnSharedPtr()
 
   08{
 
   09    shared_ptr<int> p(new int(1000));
 
   10    shared_ptr<int> p2(p);
 
   11    shared_ptr<int> p3=p;
 
   12    shared_ptr<int> p4; 
 
   13    p4=p2;
 
   14    return p;
 
   15}
 
   16 
 
   17int main()
 
   18{
 
   19    shared_ptr<int> p1 = ReturnSharedPtr();
 
   20    printf("%d\n", *p1);
 
   21    return 0;
 
   22}

下面是运行结果：

shared_ptr.h 169行是__shared_count拷贝构造时增加引用计数，184行是__shared_count赋值操作，161行是__share_count的析构时减少引用计数， 79行是释放引用对象的内存。

 
   1/usr/include/c++/4.4/tr1/shared_ptr.h:169 costaxu debug refcount: 2
 
   2/usr/include/c++/4.4/tr1/shared_ptr.h:169 costaxu debug refcount: 3
 
   3/usr/include/c++/4.4/tr1/shared_ptr.h:184 costaxu debug refcount: 4
 
   4/usr/include/c++/4.4/tr1/shared_ptr.h:161 costaxu debug refcount: 3
 
   5/usr/include/c++/4.4/tr1/shared_ptr.h:161 costaxu debug refcount: 2
 
   6/usr/include/c++/4.4/tr1/shared_ptr.h:161 costaxu debug refcount: 1
 
   71000
 
   8/usr/include/c++/4.4/tr1/shared_ptr.h:79 costaxu debug 
 
   9/usr/include/c++/4.4/tr1/shared_ptr.h:161 costaxu debug refcount: 0

shared_ptr线程安全性问题

关于shared_ptr的线程安全性。查了一些网上的资料，有的说是安全的，有的说不安全。引用CSDN上一篇比较老的帖子，它是这样说的：

“Boost 文档对于 shared_ptr 的线程安全有一段专门的记述，内容如下：
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 threads. Different shared_ptr instances can be "written to" (accessed using mutable operations such as operator= or reset) simultaneosly by multiple threads (even when these instances are copies, and share the same reference count underneath.)
Any other simultaneous accesses result in undefined behavior.
翻译为中文如下：
shared_ptr 对象提供与内建类型一样的线程安全级别。一个 shared_ptr 实例可以同时被多个线程“读”（仅使用不变操作进行访问）。不同的 shared_ptr 实例可以同时被多个线程“写入”（使用类似 operator= 或 reset 这样的可变操作进行访问）（即使这些实例是拷贝，而且共享下层的引用计数）。
任何其它的同时访问的结果会导致未定义行为。”

这几句话比较繁琐，我总结一下它的意思：

1 同一个shared_ptr被多个线程“读”是安全的。

2 同一个shared_ptr被多个线程“写”是不安全的。

3 共享引用计数的不同的shared_ptr被多个线程”写“ 是安全的。

如何印证上面的观点呢？

其实第一点我觉得比较多余。因为在多个线程中读同一个对象，在正常情况下不会有什么问题。

所以问题就是：如何写程序证明同一个shared_ptr被多个线程"写"是不安全的？

我的思路是，在多个线程中同时对一个shared_ptr循环执行两遍swap。 shared_ptr的swap函数的作用就是和另外一个shared_ptr交换引用对象和引用计数，是写操作。执行两遍swap之后, shared_ptr引用的对象的值应该不变。

程序如下：

 
   01#include <stdio.h>
 
   02#include <tr1/memory>
 
   03#include <pthread.h>
 
   04 
 
   05using std::tr1::shared_ptr;
 
   06 
 
   07shared_ptr<int> gp(new int(2000));
 
   08 
 
   09shared_ptr<int>  CostaSwapSharedPtr1(shared_ptr<int> & p)
 
   10{
 
   11    shared_ptr<int> p1(p);
 
   12    shared_ptr<int> p2(new int(1000));
 
   13    p1.swap(p2);
 
   14    p2.swap(p1);
 
   15    return p1;
 
   16}
 
   17 
 
   18shared_ptr<int>  CostaSwapSharedPtr2(shared_ptr<int> & p)
 
   19{
 
   20    shared_ptr<int> p2(new int(1000));
 
   21    p.swap(p2);
 
   22    p2.swap(p);
 
   23    return p;
 
   24}
 
   25 
 
   26 
 
   27void* thread_start(void * arg)
 
   28{
 
   29    int i =0;
 
   30    for(;i<100000;i++)
 
   31    {
 
   32        shared_ptr<int> p= CostaSwapSharedPtr2(gp);
 
   33        if(*p!=2000)
 
   34        {
 
   35            printf("Thread error. *gp=%d \n", *gp);
 
   36            break;
 
   37        }
 
   38    }
 
   39    printf("Thread quit \n");
 
   40    return 0;
 
   41}
 
   42 
 
   43 
 
   44 
 
   45int main()
 
   46{
 
   47    pthread_t thread;
 
   48    int thread_num = 10, i=0;
 
   49    pthread_t* threads = new pthread_t[thread_num];
 
   50    for(;i<thread_num;i++)
 
   51        pthread_create(&threads[i], 0 , thread_start , &i);
 
   52    for(i=0;i<thread_num;i++)
 
   53        pthread_join(threads[i],0);
 
   54    delete[] threads;
 
   55    return 0;
 
   56}

这个程序中我启了10个线程。每个线程调用10万次 CostaSwapSharedPtr2函数。在CostaSwapSharePtr2函数中，对同一个share_ptr全局变量gp进行两次swap（写操作），在函数返回之后检查gp的值是否被修改。如果gp值被修改，则证明多线程对同一个share_ptr执行写操作是不安全的。

程序运行的结果如下：

 
   01Thread error. *gp=1000 
 
   02Thread error. *gp=1000 
 
   03Thread quit 
 
   04Thread quit 
 
   05Thread error. *gp=1000 
 
   06Thread quit 
 
   07Thread error. *gp=1000 
 
   08Thread quit 
 
   09Thread error. *gp=1000 
 
   10Thread quit 
 
   11Thread error. *gp=1000 
 
   12Thread quit 
 
   13Thread error. *gp=1000 
 
   14Thread quit 
 
   15Thread error. *gp=1000 
 
   16Thread quit 
 
   17Thread error. *gp=1000 
 
   18Thread quit 
 
   19Thread quit

10个线程有9个出错。证明多线程对同一个share_ptr执行写操作是不安全的。我们在程序中，如果不运行CostaSwapSharedPtr2，改成运行CostaSwapSharedPtr1呢？ CostaSwapSharedPtr1和CostaSwapSharedPtr2的区别在于，它不是直接对全局变量gp进行写操作，而是将gp拷贝出来一份再进行写操作。运行的结果如下：

 
   01costa@pepsi:~/test/cpp/shared_ptr$ ./b
 
   02Thread quit 
 
   03Thread quit 
 
   04Thread quit 
 
   05Thread quit 
 
   06Thread quit 
 
   07Thread quit 
 
   08Thread quit 
 
   09Thread quit 
 
   10Thread quit 
 
   11Thread quit

跑了很多次都没有出错。说明共享引用计数的不同的shared_ptr执行swap是线程安全的。BOOST文档是可信的。

补充一个问题：为什么shared_ptr可以作为STL标准容器的元素，而auto_ptr不可以

这篇文章小结一下：

1 shared_ptr是一个非常实用的智能指针。

2 shared_ptr的实现机制是在拷贝构造时使用同一份引用计数。

3 对同一个shared_ptr的写操作不是线程安全的。对使用同一份引用计数的不同shared_ptr是线程安全的

dodo_check

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
shared_ptr 实现

前几天有个人问了我一个问题：如何将一个智能指针作为函数的返回值传递出来。当时这个问题一下子把我问倒了，后来经人提醒有一个叫shared_ptr的智能指针可以解决这个问题。将shared_ptr作为函数返回值的代码是这样的： 01#include 02#include 03
复制链接

扫一扫