다시 copyon_write 임계구 축소의 예

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<vector>
#include<assert.h>
#include<boost/shared_ptr.hpp>
#include<boost/weak_ptr.hpp>
#include<boost/noncopyable.hpp>
using namespace std;
using namespace boost;
class Mutex:public noncopyable{//      
    public:
        Mutex(){
            pthread_mutex_init(&mutex,NULL);
        }
        void lock(){
            pthread_mutex_lock(&mutex);
        }
        void unlock(){
            pthread_mutex_unlock(&mutex);
        }
        ~Mutex(){
            pthread_mutex_destroy(&mutex);
        }
        pthread_mutex_t* getMutex(){
            return &mutex;
        }
    private:
        mutable pthread_mutex_t mutex;
};
class MutexLockGuard:noncopyable{//RAII     
    public:
        explicit MutexLockGuard(Mutex& mutex):mutex_(mutex){
            mutex_.lock();
        }
        ~MutexLockGuard(){
            mutex_.unlock();
        }
    private:
        Mutex& mutex_;//     ，Mutex   noncopyable       
};
class test:noncopyable{
    public:
        test():ptr(new vector<int>),mutex(){}
        void show(){
            shared_ptr<vector<int> > temp=get();
            for(vector<int>::iterator it=temp->begin();it!=temp->end();it++){
                cout<<*it<<" ";
            }
            cout<<endl;
        }
        void add(int x){//      
            MutexLockGuard guard(mutex);
            if(!ptr.unique()){
                shared_ptr<vector<int> > temp(new vector<int>(*ptr));
                ptr.swap(temp);
            }
            assert(ptr.unique());
            ptr->push_back(x);
        }
        void add(vector<int> &x){//      
            shared_ptr<vector<int> > temp(new vector<int>(x));
            if(temp){
                MutexLockGuard guard(mutex);
                ptr.swap(temp);//   ptr=temp              (    ，          )，                ，    swap             ....        ...
            }//        
        }
        shared_ptr<vector<int> > get(){
            return ptr;
        }
    private:
        mutable Mutex mutex;
        shared_ptr<vector<int> > ptr;//  shared_ptr    
};
shared_ptr<test> globalPtr(new test);
void* worker1(void* arg){
    sleep(1);
    globalPtr->show();
    sleep(1);
    globalPtr->show();
}
void* worker2(void* arg){
    globalPtr->add(10);//      
    sleep(2);
    vector<int> temp(1,100);
    globalPtr->add(temp);//      
}
int main(){
    pthread_t pid1,pid2;
    pthread_create(&pid1,NULL,worker1,NULL);
    pthread_create(&pid2,NULL,worker2,NULL);
    pthread_join(pid1,NULL);
    pthread_join(pid2,NULL);
    return 0;
}