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()