备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

linux下使用读写锁

2013-04-23 745
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：     在多线程程序中，有一种读写者的问题，即对某些资源的访问，存在两种可能的情况，一种是访问必须排他的，称为写操作；另外一种访问是可共享的，称为读操作。     处理读写着问题的两种常见策略是：强读者同步和强写者同步。
    在多线程程序中，有一种读写者的问题，即对某些资源的访问，存在两种可能的情况，一种是访问必须排他的，称为写操作；另外一种访问是可共享的，称为读操作。
    处理读写着问题的两种常见策略是：强读者同步和强写者同步。在强读者同步过程中，总是给读者优先权，只要写着当前没有进行写操作，读者就可以获得访问权。在强写者同步过程中，通常将优先权先交给写者，而将读者延迟到所有等待的或者活动的写者都完成为止。简单的说：
    （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读写
nothingfinal
目录
相关文章
泡沫o0
|
2月前
|
Linux API C++
【Linux C/C++ 线程同步 】Linux API 读写锁的编程使用
【Linux C/C++ 线程同步 】Linux API 读写锁的编程使用
泡沫o0
21 1
新法
|
4月前
|
Linux
Linux在文件特定偏移量处读写pread和pwrite
系统调用 pread()和 pwrite()完成与 read()和 write()相类似的工作，只是前两者会在 offset 参数所指定的位置进行文件 I/O 操作，而非始于文件的当前偏移量处，且它们不会改变文件的当前偏移量。
新法
48 0
Linux在文件特定偏移量处读写pread和pwrite
新法
|
4月前
|
Linux
Linux io多块读写readv函数和writev函数
fd参数是被操作的目标文件描述符。iov参数的类型是iovec结构数组，该结构体描述一块内存区。iovcnt参数是iov数组的长度，即有多少块内存数据需要从fd读出或写到fd。readv和writev在成功时返回读出/写入fd的字节数，失败则返回-1并设置errno。readv函数将数据从文件描述符读到分散的内存块中，即分散读；writev函数则将多块分散的内存数据一并写入文件描述符中，即集中写。
新法
20 0
橙留香写代码
|
4月前
|
Linux
【Linux C 几种锁的性能对比】 1.读写锁 2.互斥锁 3.自旋锁 4.信号量 5.rcu
【Linux C 几种锁的性能对比】 1.读写锁 2.互斥锁 3.自旋锁 4.信号量 5.rcu
橙留香写代码
36 0
花落已飘
|
5月前
|
Linux
Linux线程同步(try锁和读写锁)
Linux线程同步(try锁和读写锁)
花落已飘
33 0
ST小智
|
3月前
|
Linux
Linux多线程中互斥锁、读写锁、自旋锁、条件变量、信号量详解
Linux多线程中互斥锁、读写锁、自旋锁、条件变量、信号量详解
ST小智
75 0
Linux多线程中互斥锁、读写锁、自旋锁、条件变量、信号量详解
ST小智
|
7月前
|
移动开发 Linux Windows
linux系统中QT进行文本读写操作的方法
linux系统中QT进行文本读写操作的方法
ST小智
54 0
cai-cai
|
9月前
|
Linux
Linux文件读写操作全面解析
在Linux系统中，文件读写操作是非常常见和重要的任务。无论是读取配置文件、处理日志文件还是进行数据持久化，文件读写都是必不可少的。本文将全面解析Linux下文件读写的各个方面，包括打开文件、读取文件内容、写入文件内容以及错误处理。我们将详细介绍相关的系统调用和C标准库函数，并提供丰富的代码示例。
cai-cai
529 0
Overboom
|
10月前
|
Linux 编译器
Linux系统应用编程---线程同步基础（互斥量、死锁、读写锁）
Linux系统应用编程---线程同步基础（互斥量、死锁、读写锁）
Overboom
92 0
林夕07
|
11月前
|
存储 缓存 安全
Linux下线程同步（带你了解什么是互斥锁、死锁、读写锁、条件变量、信号量等）
Linux下线程同步（带你了解什么是互斥锁、死锁、读写锁、条件变量、信号量等）
林夕07
123 0

热门文章

最新文章

  • 1
    Linux基础与服务器架构综合小实践
  • 2
    网络名称空间在Linux虚拟化技术中的位置
  • 3
    Redis的安装（Linux版）
  • 4
    Linux如何检查文件夹的大小？
  • 5
    Linux进程和计划任务管理
  • 6
    安装【银河麒麟V10】linux系统--并挂载镜像
  • 7
    工作中常用到的Linux命令
  • 8
    Linux文件编程(open read write close函数)
  • 9
    Linux文件常用操作
  • 10
    Linux手动清理Linux脚本日志定时清理日志和log文件执行表达式
  • 1
    linux实验参考1
    13
  • 2
    Linux中认识路径的概念
    9
  • 3
    Linux创建空白文件
    9
  • 4
    通过Linux挂载Windows端NFS服务实现板端Linux传输文件到PC
    35
  • 5
    Linux实现socket网络通信
    14
  • 6
    Linux 常用命令汇总（五）：网络操作命令
    27
  • 7
    Linux安装HBase的详细教程及常用方法
    117
  • 8
    Linux系统之rename命令的基本使用
    145
  • 9
    Linux系统之file命令的基本使用
    45
  • 10
    Linux 常用命令汇总（四）：信息显示 & 用户管理
    28

    • 相关课程

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

    • 相关电子书

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

    • 相关实验场景

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

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考