shared_ptr:线程安全、循环引用

shared_ptr:线程安全、循环引用

shared_ptr用来管理堆对象可以避免delete，但是注意shared_ptr本身是个对象因此其的声明周期、shared_ptr对象的读写操作非原子化那么在多线程环境下仍然存在很多问题，即shared_ptr对象本身的线程安全级别非100%。在多线程中访问同一个shared_ptr对象应该用mutex保护。
shared_ptr使用不当会延长锁管理的对象(假设为A)的生命周期，即有什么地方不小心留下一个shared_ptr的拷贝，那么对象A生命期无疑被延长了，因为对象计数不为0将不会被销毁。boost::bind会将函数参数拷贝一份，那么

shared_ptr<T>one, boost::function<void()> fp=boost::bind(&fun,one)//这种情况会下one管理的对象生命期一定晚于fp对象。

shared_ptr可能会导致循环引用即:对象A持有一个关于B的shared_ptr，B持有一个关于A的shared_ptr，那么A、B离开作用域的时候它们的计数都不为0(因为对方持有一个shared_ptr指向自己)而谁也不肯先释放这个shared_ptr,最后造成内存泄露。解决方法是：A持有关于B的shared_ptr,B持有关于A的weak_ptr。
当一个管理对象A的shared_ptr离开作用域且计数变为0时那么对象A将在这个线程析构(这个线程可能不是创建A的线程)，若析构比较费事，那么析构A的线程将被拖累，解决办法是：找个专门的线程管理所有的shared_ptr对象，并执行析构操作。
我曾犯过的一个错误：若shared_ptr管理对象A，假设对象里面有new的堆内存，在对象A销毁前(即shared_ptr计数大于0)的时候，在某个地方A通过某些操作释放了A里里面的堆内存….那么最后的结果是？不错，double free,在A存活的时候释放了A里面的部分内存，那么在shared_ptr计数为0要销毁A的时候又去释放那块内存，然后就double free了。所以记住:避免shared_ptr管理的对象直接的内存管理操作以免造成重复释放。
下面是多线程共享一个shared_ptr对象时的保护措施：

#include<iostream>  
#include<string>  
#include<unistd.h>  
#include<pthread.h>  
#include<boost/shared_ptr.hpp>  
#include<boost/weak_ptr.hpp>  
using namespace std;  
using namespace boost;  
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;//保护globalPtr的互斥量  
class test{//shared_ptr管理的对象(假设为A)  
    public:  
        void show(string s){  
            cout<<"test::show()  in: "<<s<<endl;  
        }  
};  
shared_ptr<test> globalPtr(new test);  

void fun(const shared_ptr<test>& ptr,string s){//用于展示多层函数传递shared_ptr时只用最外层函数持有shared_ptr对象实体，内层函数可以用const reference传递，毕竟大多数都是操作shared_ptr管理的对象而不是shared_ptr本身，const reference不会遇见返回拷贝shared_ptr对象导致的性能问题  
    ptr->show(s);//操作shared_ptr管理的对象  
}  
void read(){//读globalPtr时候使用mutex保护  
    shared_ptr<test> localptr;//减小临界区  
    {  
        pthread_mutex_lock(&mutex);  
        localptr=globalPtr;//以后的操作只与localptr有关  
        pthread_mutex_unlock(&mutex);  
    }  
    fun(localptr,"read()");  
}  
void write(){//重写globalPtr时使用mutex保护  
    shared_ptr<test> newptr(new test);//重写globalPtr  
    shared_ptr<test> lockptr;//###1  
    {  
        pthread_mutex_lock(&mutex);  
        //globalPtr=newptr;//###2//这里与###1的区别是：直接使用本语句将有可能出现：globalPtr管理的对象A计数为1即这里将newptr赋给globalPtr后对象A将会被析构，则会使临界区变长，那么解决方式就是按照###1的那几句话  
        lockptr.swap(globalPtr);//###1  
        globalPtr=newptr;//###1  
        pthread_mutex_unlock(&mutex);  
    }  
    fun(newptr,"write()");  
    //fun(shared_ptr<test> one(new test),g()//构造一个临时的shared_ptr作为函数参数，函数参数求值顺序不一定，可能:new test第一，g()第二但是如果g()抛出一个异常，那么永远不可能到达shared_ptr的构造函数  
}  
void reset(){//销毁shared_ptr对象  
    shared_ptr<test> localptr;//同样为了缩小临界区  
    {  
        pthread_mutex_lock(&mutex);  
        localptr.swap(globalPtr);//globalPtr轻松就置空了且不会引起所管理的对象A在这里被析构，临界区非常小  
        pthread_mutex_unlock(&mutex);  
    }  
    fun(localptr,"reset()");  
}  
void* worker(void* arg){  
    int* x=(int*)arg;  
    switch(*x){  
        case 1:  
            read();  
            break;  
        case 2:  
            write();  
            break;  
        case 3:  
            sleep(1);//pid3线程为了让其它两个线程执行完，不然这里使globalPtr置空了其它线程会报错  
            reset();  
            break;  
        default:  
            cout<<"are you kidding me"<<endl;  
    }  
}  
int main(){  
    pthread_t pid1,pid2,pid3;  
    int i=1;  
    pthread_create(&pid1,NULL,worker,&i);  
    int j=2;//本来想用i++的但是所有线程都执行i=3的情形这说明：在前面两个线程还没有提取i=1,i=2的时候，线程3已经将i置为3了那么前两个线程就提取了i=3,这个错误以前犯过...哎...  
    pthread_create(&pid2,NULL,worker,&j);  
    int k=3;  
    pthread_create(&pid3,NULL,&worker,&k);  
    pthread_join(pid1,NULL);  
    pthread_join(pid2,NULL);  
    pthread_join(pid3,NULL);  
    return 0;  
}  

输出结果：

test::show() in: write()test::show() in: read()
test::show() in: reset()

shared_ptr循环引用的例子：内存泄露问题

#include<iostream>  
#include<boost/shared_ptr.hpp>  
#include<boost/weak_ptr.hpp>  
using namespace std;  
using namespace boost;  
class B;  
class A{  
    public:  
        shared_ptr<B> ptr_A;  
        ~A(){  
            cout<<"~A()"<<endl;  
        }  
};  
class B{  
    public:  
        //shared_ptr<A> ptr_B;//当采用shared_ptr指向A时会形成循环引用，则什么都不会输出说明对象没有被析构，可怕的内存泄露....  
        weak_ptr<A> ptr_B;//当采用弱引用时，避免了循环引用，有输出，说明对象被析构了  
        ~B(){  
            cout<<"~B()"<<endl;  
        }  
};  
int main(){  
    shared_ptr<A> a(new A);  
    shared_ptr<B> b(new B);  
    a->ptr_A=b;  
    b->ptr_B=a;//若是循环引用：当a、b退出作用域的时候，A对象计数不为1(b保留了个计数呢),同理B的计数也不为1,那么对象将不会被销毁，内存泄露了...  
    return 0;  
}  

若是循环引用则什么输出都没有即对象没有析构，内存泄露了。
若是B持有A的weak_ptr则输出：

~A()
~B()