AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

linux下使用读写锁

2013-04-23 708
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：     在多线程程序中，有一种读写者的问题，即对某些资源的访问，存在两种可能的情况，一种是访问必须排他的，称为写操作；另外一种访问是可共享的，称为读操作。     处理读写着问题的两种常见策略是：强读者同步和强写者同步。
    在多线程程序中，有一种读写者的问题，即对某些资源的访问，存在两种可能的情况，一种是访问必须排他的，称为写操作；另外一种访问是可共享的，称为读操作。
    处理读写着问题的两种常见策略是：强读者同步和强写者同步。在强读者同步过程中，总是给读者优先权，只要写着当前没有进行写操作，读者就可以获得访问权。在强写者同步过程中，通常将优先权先交给写者，而将读者延迟到所有等待的或者活动的写者都完成为止。简单的说：
    （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_castTest*>(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_castTest*>(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; iTHREADS_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_castTest*>(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_castTest*>(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; iTHREADS_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:

点击(此处)折叠或打开

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

    参考：
         Linux 下的线程读写锁
        http://www.cppblog.com/bigsml/archive/2006/09/07/12137.html
 
文章标签：
Linux
关键词：
Linux锁
Linux读写锁
xumaojun
目录
相关文章
游客mldfis24krfue
|
2月前
|
监控 关系型数据库 MySQL
在Linux中，mysql的innodb如何定位锁问题？
在Linux中，mysql的innodb如何定位锁问题？
游客mldfis24krfue
66 2
听风的鱼鱼儿
|
4月前
|
监控 Linux 数据处理
lslocks：Linux系统中的锁信息查看利器
`lslocks`是Linux工具，用于查看系统上的文件锁信息，帮助诊断进程同步问题。它显示持有锁的进程、锁类型（如POSIX、flock）和状态。通过简洁的输出，用户能识别死锁和资源争用，优化性能。结合其他命令如`grep`和`awk`可增强分析能力。需适当权限运行，定期监控以预防并发访问问题，处理死锁时要谨慎。
听风的鱼鱼儿
99 6
邢仕冲的一亩三分地
|
4月前
|
API
linux---线程互斥锁总结及代码实现
linux---线程互斥锁总结及代码实现
邢仕冲的一亩三分地
60 5
邢仕冲的一亩三分地
|
4月前
|
API
Linux---线程读写锁详解及代码实现
Linux---线程读写锁详解及代码实现
邢仕冲的一亩三分地
51 1
დ旧言~
|
3月前
|
安全 算法 Linux
【Linux】线程安全——补充|互斥、锁|同步、条件变量（下）
【Linux】线程安全——补充|互斥、锁|同步、条件变量（下）
დ旧言~
41 0
დ旧言~
|
3月前
|
存储 安全 Linux
【Linux】线程安全——补充|互斥、锁|同步、条件变量（上）
【Linux】线程安全——补充|互斥、锁|同步、条件变量（上）
დ旧言~
50 0
热爱嵌入式的小佳同学
|
5月前
|
Unix Shell Linux
linux互斥锁（pthread_mutex)知识点总结
linux互斥锁（pthread_mutex)知识点总结
热爱嵌入式的小佳同学
212 4
Yawesh
|
5月前
|
算法 安全 Linux
【探索Linux】P.20（多线程 | 线程互斥 | 互斥锁 | 死锁 | 资源饥饿）
【探索Linux】P.20（多线程 | 线程互斥 | 互斥锁 | 死锁 | 资源饥饿）
Yawesh
47 0
泡沫o0
|
5月前
|
Linux API C++
【Linux C/C++ 线程同步 】Linux API 读写锁的编程使用
【Linux C/C++ 线程同步 】Linux API 读写锁的编程使用
泡沫o0
47 1
泡沫o0
|
5月前
|
Linux 调度 C语言
【Linux C/C++ 线程同步 】Linux互斥锁和条件变量：互斥锁和条件变量在Linux线程同步中的编程实践
【Linux C/C++ 线程同步 】Linux互斥锁和条件变量：互斥锁和条件变量在Linux线程同步中的编程实践
泡沫o0
132 0

热门文章

最新文章

  • 1
    Linux 2 unit1 虚拟机,自动安装
  • 2
    Linux下群集服务简介&lvs集群详解
  • 3
    linux python eclipse 安装
  • 4
    使用Android、S3C6410开发板和Ubuntu测试Linux驱动
  • 5
    VM 6+linux4.4+裸设备+ORACLE10G RAC 安装
  • 6
    【原创】手把手教你Linux下的多线程设计－－Linux下多线程编程详解(四)
  • 7
    linux网络编程-----实现并发访问网站------
  • 8
    老男孩教育每日一题-day59-Linux root 密码忘了,如何找回来？
  • 9
    VMware+Linux AS4 为虚拟机新增了硬盘详细方法
  • 10
    Linux下vi的列模式
  • 1
    Linux中认识路径的概念
    36
  • 2
    Linux创建空白文件
    51
  • 3
    通过Linux挂载Windows端NFS服务实现板端Linux传输文件到PC
    348
  • 4
    Linux实现socket网络通信
    63
  • 5
    Linux安装HBase的详细教程及常用方法
    468
  • 6
    Linux系统之rename命令的基本使用
    207
  • 7
    Linux系统之file命令的基本使用
    97
  • 8
    Linux 常用命令汇总（四）：信息显示 & 用户管理
    99
  • 9
    【Linux】—— 信号的基本介绍（一）
    84
  • 10
    【Linux】—— 详解动态库和静态库
    301

    • 相关课程

    更多
  • Linux高级网络应用 - 网络管理与配置实战
  • Linux MySQL服务器搭建与应用
  • Linux基本命令
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 相关实验场景

    更多
  • Linux指令入门-文件与权限
  • Linux指令入门-系统管理
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • Alibaba Cloud Linux操作系统的安装及使用
  • Alibaba Cloud Linux操作系统Shell程序
  • 手动部署MySQL数据库（Alibaba Cloud Linux 2）

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    无影云桌面