Chinaunix首页 | 论坛 | 博客

upon_88

首页　| 　博文目录　| 　关于我

upon_88

  • 博客访问： 333873
  • 博文数量： 124
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 321
  • 用 户 组： 普通用户
  • 注册时间： 2014-08-04 16:09
文章分类

全部博文（124）

文章存档

2014年（124）

我的朋友
最近访客
推荐博文
相关博文
linux下使用读写锁

分类： LINUX

2014-08-06 14:12:37

原文地址：linux下使用读写锁 作者：yuyunliuhen

    在多线程程序中，有一种读写者的问题，即对某些资源的访问，存在两种可能的情况，一种是访问必须排他的，称为写操作；另外一种访问是可共享的，称为读操作。
    处理读写着问题的两种常见策略是：强读者同步和强写者同步。在强读者同步过程中，总是给读者优先权，只要写着当前没有进行写操作，读者就可以获得访问权。在强写者同步过程中，通常将优先权先交给写者，而将读者延迟到所有等待的或者活动的写者都完成为止。简单的说：
    （1）可以同时存在多个读操作
    （2）写必须互斥（只允许一个写操作，不能读写操作同时进行）
    （3）写操作优先于读操作，(一旦有写操作，后续的读操作必须等待，唤醒时有限考虑写操作)
    下面是两种读写锁的使用示例.
    一：POSIX 下的rw_lock

点击(此处)折叠或打开

  1. #include <pthread.h>
  2. #include <cstdlib>
  3. #include <ctime>
  4. #include <iostream>
  5. using namespace std;

  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.         }

  51.         const int THREADS_NO = rand()%100;
  52.         pthread_t* threads = new pthread_t[THREADS_NO];

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

  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;

  7. class RWLock
  8. {
  9. private :
  10.     pthread_mutex_t cnt_mutex;
  11.     pthread_cond_t rw_cond;
  12.     int rd_cnt, wr_cnt;

  14.     RWLock(const RWLock&);
  15.     RWLock& operator= (const RWLock&);

  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.     }

  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.     }

  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.     }

  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.     }

  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.     }

  65.     ~RWLock()
  66.     {
  67.         pthread_mutex_destroy(&cnt_mutex);
  68.         pthread_cond_destroy(&rw_cond);
  69.     }
  70. };

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

  103.         const int THREADS_NO = rand()%100;
  104.         pthread_t* threads = new pthread_t[THREADS_NO];

  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.         }

  116.         for(int i=0; i<THREADS_NO; i++)
  117.         {
  118.             pthread_join(threads[i],NULL);
  119.         }

  121.         delete[] threads;
  122.     }
  123. };

  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

    参考：
        http://www.cppblog.com/bigsml/archive/2006/09/07/12137.html
 
阅读(782) | 评论(0) | 转发(0) |
0

上一篇：Linux 内核的同步机制--原子操作

下一篇：常用的几种内存池技术

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6