linux下使用读写锁

    在多线程程序中，有一种读写者的问题，即对某些资源的访问，存在两种可能的情况，一种是访问必须排他的，称为写操作；另外一种访问是可共享的，称为读操作。

    处理读写着问题的两种常见策略是：强读者同步和强写者同步。在强读者同步过程中，总是给读者优先权，只要写着当前没有进行写操作，读者就可以获得访问权。在强写者同步过程中，通常将优先权先交给写者，而将读者延迟到所有等待的或者活动的写者都完成为止。简单的说：

    （1）可以同时存在多个读操作

    （2）写必须互斥（只允许一个写操作，不能读写操作同时进行）

    （3）写操作优先于读操作，(一旦有写操作，后续的读操作必须等待，唤醒时有限考虑写操作)

    下面是两种读写锁的使用示例.
    一：POSIX 下的rw_lock

点击(此处)折叠或打开

1. #include <pthread.h>
   
2. #include <cstdlib>
   
3. #include <ctime>
   
4. #include <iostream>
   
5. using namespace std;
   
6. 
   
7. static int count = 0;
   
8. class Test
   
9. {
   
10. private :
    
11.     pthread_rwlock_t rwlock;
    
12.     
    
13.     static void* shared_task_handler(void* arg)
    
14.     {
    
15.         Test* testptr = static_cast<Test*>(arg);
    
16.         pthread_rwlock_rdlock(&testptr->rwlock);
    
17.         //    do the shared task here
    
18.         cout << "read---count = " << count << endl;
    
19.         if (pthread_rwlock_unlock(&testptr->rwlock) )
    
20.         {
    
21.             cout << "read unlock error " << endl;
    
22.         }
    
23.         return NULL;
    
24.     }
    
25.     
    
26.     static void * exclusive_task_handler(void * arg)
    
27.     {
    
28.         Test* testptr = static_cast<Test*>(arg);
    
29.         pthread_rwlock_wrlock(&testptr->rwlock);
    
30.         //do the exclusive task here
    
31.         ++count;
    
32.         cout << "write--count = " << count << endl;
    
33.         if (pthread_rwlock_unlock(&testptr->rwlock) )
    
34.         {
    
35.             cout << "write unlock error " << endl;
    
36.         }
    
37.         return NULL;
    
38.     }
    
39.     
    
40. public :
    
41.     typedef void* (*ThreadFunc) (void*);
    
42.     void start()
    
43.     {
    
44.         srand(time(NULL));
    
45.         
    
46.         if( pthread_rwlock_init(&rwlock,NULL) )
    
47.         {
    
48.             cout << "rwlock init error " << endl;
    
49.         }
    
50. 
    
51.         const int THREADS_NO = rand()%100;
    
52.         pthread_t* threads = new pthread_t[THREADS_NO];
    
53. 
    
54.         for(int i = 0; i < THREADS_NO; ++i)
    
55.         {
    
56.             ThreadFunc tmpfunc = rand() % 2 ? shared_task_handler : exclusive_task_handler;
    
57.             if (pthread_create(threads+i,NULL,tmpfunc,this))
    
58.             {
    
59.                 cerr << "pthread_create fails" << endl;
    
60.                 exit(1);
    
61.             }
    
62.         }
    
63.         rwlock
    
64.         for(int i=0; i<THREADS_NO; i++)
    
65.         {
    
66.             pthread_join(threads[i],NULL);
    
67.         }
    
68.         delete[] threads;
    
69.     }
    
70. };
    
71. 
    
72. int main()
    
73. {
    
74.     Test tmptest;
    
75.     tmptest.start();
    
76. }

output:

点击(此处)折叠或打开

1. lee@lee-desktop:~/share$ ./posix_read_write_lock
   
2. write--count = 1
   
3. write--count = 2
   
4. write--count = 3
   
5. read---count = 3
   
6. read---count = 3
   
7. read---count = 3
   
8. read---count = 3
   
9. write--count = 4
   
10. read---count = 4
    
11. write--count = 5
    
12. write--count = 6
    
13. read---count = 6
    
14. read---count = 6
    
15. read---count = 6
    
16. read---count = 6
    
17. write--count = 7
    
18. write--count = 8
    
19. read---count = 8
    
20. read---count = 8
    
21. write--count = 9
    
22. write--count = 10
    
23. read---count = 10
    
24. read---count = 10
    
25. read---count = 10
    
26. read---count = 10
    
27. read---count = 10
    
28. read---count = 10
    
29. read---count = 10
    
30. write--count = 11
    
31. write--count = 12
    
32. write--count = 13
    
33. write--count = 14
    
34. write--count = 15
    
35. read---count = 15

    二：利用pthread_cond_*  &  pthread_mutex_* 实现rw_lock

 

点击(此处)折叠或打开

1. #include <pthread.h>
   
2. #include <cstdlib>
   
3. #include <ctime>
   
4. #include <iostream>
   
5. using namespace std;
   
6. 
   
7. class RWLock
   
8. {
   
9. private :
   
10.     pthread_mutex_t cnt_mutex;
    
11.     pthread_cond_t rw_cond;
    
12.     int rd_cnt, wr_cnt;
    
13. 
    
14.     RWLock(const RWLock&);
    
15.     RWLock& operator= (const RWLock&);
    
16. 
    
17. public :
    
18.     RWLock(): rd_cnt(0),wr_cnt(0)
    
19.     {
    
20.         pthread_mutex_init(&cnt_mutex, NULL);
    
21.         pthread_cond_init(&rw_cond, NULL);
    
22.     }
    
23. 
    
24.     void get_shared_lock()
    
25.     {
    
26.         pthread_mutex_lock(&cnt_mutex);
    
27.         while (wr_cnt >0)
    
28.         {
    
29.             pthread_cond_wait(&rw_cond,&cnt_mutex);
    
30.         }
    
31.         rd_cnt++;
    
32.         pthread_mutex_unlock(&cnt_mutex);
    
33.     }
    
34. 
    
35.     void release_shared_lock()
    
36.     {
    
37.         pthread_mutex_lock(&cnt_mutex);
    
38.         rd_cnt--;
    
39.         if (0 == rd_cnt)
    
40.         {
    
41.             pthread_cond_signal(&rw_cond);
    
42.         }
    
43.         pthread_mutex_unlock(&cnt_mutex);
    
44.     }
    
45. 
    
46.     void get_exclusive_lock()
    
47.     {
    
48.         pthread_mutex_lock(&cnt_mutex);
    
49.         while (rd_cnt + wr_cnt>0)
    
50.         {
    
51.             pthread_cond_wait(&rw_cond,&cnt_mutex);
    
52.         }
    
53.         wr_cnt++;
    
54.         pthread_mutex_unlock(&cnt_mutex);
    
55.     }
    
56. 
    
57.     void release_exclusive_lock()
    
58.     {
    
59.         pthread_mutex_lock(&cnt_mutex);
    
60.         wr_cnt--;
    
61.         pthread_cond_broadcast(&rw_cond);
    
62.         pthread_mutex_unlock(&cnt_mutex);
    
63.     }
    
64. 
    
65.     ~RWLock()
    
66.     {
    
67.         pthread_mutex_destroy(&cnt_mutex);
    
68.         pthread_cond_destroy(&rw_cond);
    
69.     }
    
70. };
    
71. 
    
72. static int count = 0;
    
73. class Test
    
74. {
    
75. private :
    
76.     RWLock lock;
    
77.     
    
78.     static void* shared_task_handler(void* arg)
    
79.     {
    
80.         Test* testptr = static_cast<Test*>(arg);
    
81.         testptr->lock.get_shared_lock();
    
82.         //    do the shared task here
    
83.         cout << "read---count = " << count << endl;
    
84.         testptr->lock.release_shared_lock();
    
85.     }
    
86.     
    
87.     static void * exclusive_task_handler(void * arg)
    
88.     {
    
89.         Test* testptr = static_cast<Test*>(arg);
    
90.         testptr->lock.get_exclusive_lock();
    
91.         //do the exclusive task here
    
92.         ++count;
    
93.         cout << "write--count = " << count << endl;
    
94.         testptr->lock.release_exclusive_lock();
    
95.     }
    
96.     
    
97. public :
    
98.     typedef void* (*ThreadFunc) (void*);
    
99.     void start()
    
100.     {
     
101.         srand(time(NULL));
     
102. 
     
103.         const int THREADS_NO = rand()%100;
     
104.         pthread_t* threads = new pthread_t[THREADS_NO];
     
105. 
     
106.         for(int i = 0; i < THREADS_NO; ++i)
     
107.         {
     
108.             ThreadFunc tmpfunc = rand() % 2 ? shared_task_handler : exclusive_task_handler;
     
109.             if (pthread_create(threads+i,NULL,tmpfunc,this))
     
110.             {
     
111.                 cerr << "pthread_create fails" << endl;
     
112.                 exit(1);
     
113.             }
     
114.         }
     
115. 
     
116.         for(int i=0; i<THREADS_NO; i++)
     
117.         {
     
118.             pthread_join(threads[i],NULL);
     
119.         }
     
120. 
     
121.         delete[] threads;
     
122.     }
     
123. };
     
124. 
     
125. int main()
     
126. {
     
127.     Test tmptest;
     
128.     tmptest.start();
     
129. }

  output:

点击(此处)折叠或打开

1. lee@lee-desktop:~/share$ ./read_write_lock
   
2. read---count = 0
   
3. read---count = 0
   
4. read---count = 0
   
5. write--count = 1
   
6. read---count = 1
   
7. read---count = 1
   
8. read---count = 1
   
9. read---count = 1
   
10. write--count = 2
    
11. write--count = 3
    
12. read---count = 3
    
13. read---count = 3
    
14. read---count = 3
    
15. read---count = 3
    
16. read---count = 3
    
17. read---count = 3
    
18. read---count = 3
    
19. read---count = 3
    
20. read---count = 3
    
21. read---count = 3
    
22. read---count = 3
    
23. read---count = 3
    
24. read---count = 3
    
25. write--count = 4
    
26. write--count = 5
    
27. write--count = 6
    
28. write--count = 7
    
29. write--count = 8
    
30. write--count = 9
    
31. write--count = 10
    
32. write--count = 11
    
33. read---count = 11
    
34. write--count = 12
    
35. write--count = 13
    
36. read---count = 13
    
37. read---count = 13
    
38. write--count = 14
    
39. write--count = 15
    
40. write--count = 16
    
41. write--count = 17
    
42. write--count = 18
    
43. write--count = 19
    
44. read---count = 19
    
45. write--count = 20
    
46. read---count = 20
    
47. write--count = 21
    
48. read---count = 21
    
49. write--count = 22
    
50. read---count = 22
    
51. read---count = 22
    
52. write--count = 23
    
53. read---count = 23
    
54. read---count = 23
    
55. read---count = 23
    
56. write--count = 24
    
57. read---count = 24
    
58. write--count = 25
    
59. write--count = 26
    
60. write--count = 27
    
61. write--count = 28
    
62. read---count = 28
    
63. read---count = 28
    
64. write--count = 29
    
65. write--count = 30
    
66. read---count = 30
    
67. read---count = 30
    
68. read---count = 30
    
69. write--count = 31
    
70. read---count = 31
    
71. read---count = 31
    
72. write--count = 32
    
73. read---count = 32
    
74. write--count = 33
    
75. read---count = 33
    
76. read---count = 33
    
77. read---count = 33
    
78. read---count = 33
    
79. read---count = 33
    
80. write--count = 34
    
81. write--count = 35

    参考：

        Linux 下的线程读写锁

        http://www.cppblog.com/bigsml/archive/2006/09/07/12137.html