再看copy_on_write缩小临界区的例子

最新推荐文章于 2022-04-28 11:25:54 发布

原创最新推荐文章于 2022-04-28 11:25:54 发布 · 1.6k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#再看copy_on_write缩小临界区

Linux多线程编程同时被 2 个专栏收录

28 篇文章

订阅专栏

Linux多线程编程C++

25 篇文章

订阅专栏

本文深入探讨了在多线程环境下，如何使用C++的shared_ptr+写时拷贝策略来高效地管理资源，特别关注了在临界区析构时将析构操作移出的策略，以防止资源被意外占用或破坏。通过实例如worker线程的并发执行，展示了如何在保证线程安全的同时，灵活地添加和替换数据结构，确保了程序的稳定性和效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本例子是模拟的读者写者问题，采用shared_ptr+写时拷贝实现，其中我觉得一个比较值得注意的地方是考虑到对象可能在临界区析构而将析构移除临界区，这对于多线程来说要多看多思。

#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;
}

程序输出：
10
100