shared_ptr实现多线程读写copy-on-write

利用boost的shared_ptr可以实现“读不阻塞写 ”。过程中每次读取不需要拷贝数据，而只需要在要写的时候拷贝一份数据：

点击( 此处 )折叠或打开

1. #include <iostream>
   
2. #include <cstdlib>
   
3. #include <map>
   
4. #include <vector>
   
5. #include <boost/smart_ptr.hpp>
   
6. #include <boost/make_shared.hpp>
   
7. #include <boost/enable_shared_from_this.hpp>
   
8. #include <boost/bind.hpp>
   
9. #include <boost/function.hpp>
   
10. #include <boost/noncopyable.hpp>
    
11. 
    
12. #include <pthread.h>
    
13. #include <unistd.h>
    
14. 
    
15. using namespace std;
    
16. 
    
17. 
    
18. class mutex_lock: public boost::noncopyable
    
19. {
    
20. public:
    
21.     mutex_lock(){pthread_mutex_init(&_mutex, NULL);}
    
22.     ~mutex_lock(){pthread_mutex_destroy(&_mutex);}
    
23.     void lock() {pthread_mutex_lock(&_mutex);}
    
24.     void unlock() {pthread_mutex_unlock(&_mutex);}
    
25. private:
    
26.     pthread_mutex_t _mutex;
    
27. };
    
28. 
    
29. class mutex_locker: public boost::noncopyable
    
30. {
    
31. public:
    
32.     explicit mutex_locker(mutex_lock& lk): _lk(lk){_lk.lock();}
    
33.     ~mutex_locker(){_lk.unlock();}
    
34. private:
    
35.     mutex_lock& _lk;
    
36. };
    
37. 
    
38. 
    
39. // 负责都和写的对象
    
40. class rwobj
    
41. {
    
42. public:
    
43.     rwobj(){sp_data = boost::make_shared<vector<int> >();}
    
44.     void read_data()
    
45.     {
    
46.         boost::shared_ptr<vector<int> > sp;
    
47.         {
    
48.             cout << "--------------------- read wait" << endl;
    
49.             mutex_locker lk(l); // 临界区足够小，适合用mutex。
    
50.             sp = sp_data; // 利用局部的shared_ptr来增加数据的引用计数，告诉写线程不要修改这份数据
    
51.             cout << "read sleep 1" << endl;
    
52.             sleep(1); // 为了阻塞其它线程
    
53.         }
    
54. 
    
55.         cout << "read size " << sp->size() << endl;
    
56.         cout << "read sleep 2" << endl;
    
57.         sleep(2);
    
58.     }
    
59. 
    
60.     void write_data(int i)
    
61.     {
    
62.         {
    
63.             cout << "------------------------------ write wait" << endl;
    
64.             mutex_locker lk(l); // 写线程的临界区比较大
    
65.             if(!sp_data.unique())
    
66.             {
    
67.                 // 如果sp_data引用计数大于1，说明有其他线程在读（通过read_data()提升了引用计数）。
    
68.                 // 此时将数据复制一份，再利用reset或者swap让sp_data指向新数据，老数据让读线程继续读。
    
69.                 // 这个写线程现在独占了sp_data，而之前那份数据在所有读线程读完之后，引用计数会变成0，被最后一个读线程自动析构。
    
70.                 sp_data.reset(new vector<int>(*sp_data));
    
71.                 cout << "-------------------------------- copy on write" << endl;
    
72.             }
    
73.             sp_data->push_back(i);
    
74.         }
    
75.         cout << "sleep write" << endl;
    
76.         sleep(1);
    
77.     }
    
78. private:
    
79.     boost::shared_ptr<vector<int> > sp_data;
    
80.     mutex_lock l;
    
81. };
    
82. 
    
83. 
    
84. rwobj obj;
    
85. 
    
86. // 读线程
    
87. void* read_thread(void* arg)
    
88. {
    
89.     while(1)
    
90.     {
    
91.         obj.read_data();
    
92.     }
    
93. }
    
94. 
    
95. 写线程
    
96. void* write_thread(void* arg)
    
97. {
    
98.     int i = 1;
    
99.     while(1)
    
100.     {
     
101.         obj.write_data(i++);
     
102.     }
     
103. }
     
104. 
     
105. int main()
     
106. {
     
107.     pthread_t thread1,thread2, thread3;
     
108.     pthread_create(&thread1, NULL, &read_thread, NULL );
     
109.     pthread_create(&thread2, NULL, &read_thread, NULL );
     
110.     pthread_create(&thread3, NULL, &write_thread, NULL );
     
111.     pthread_join(thread1,NULL);
     
112.     pthread_join(thread2,NULL);
     
113.     pthread_join(thread3,NULL);
     
114.     return 0;
     
115. }

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/26239116/viewspace-2125592/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/26239116/viewspace-2125592/