devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

关于读写锁以及用互斥锁和条件变量实现读写锁（写优先）_用读写锁的时候要用互斥锁保护吗

作者：凡人多烦事01 | 2024-03-29 18:11:05

赞

踩

用读写锁的时候要用互斥锁保护吗
读写锁包括读取锁和写入锁，多个读线程可以同时访问共享数据；
写线程必须等待所有读线程都释放锁以后，才能取得锁；
同样的，读线程必须等待写线程释放锁后，才能取得锁；
也就是说读写锁要确保的是如下互斥关系：可以同时读，但是读-写，写-写都是互斥的；
明白这一点就很好做了。

读写锁的分配规则：
1.只要没有线程持有某个给定的读写锁用于写，那么任意数目的线程可以持有该读写锁写锁用于读。
2.仅当没有线程持有某个给定的的读写锁用于读或者用于写时，才能分配该读写锁用于写。

通俗点说就是当没有写锁时，就可以加读锁且任意线程可以同时加，而写锁只能有一个，且必须在没有读锁时才能加上，一般来说，写锁优先。
读写锁的数据类型为pthread_rwlock_t，可以用PTHREAD_RWLOCK_INITIALIZER来初始化。 

  1. #include<pthread.h>
  2. int pthread_rwlock_rdlock(pthread_rwlock_t *rwptr);
  3. int pthread_rwlock_wrlock(pthread_rwlock_t *rwptr);
  4. int pthread_rwlock_unlock(pthread_rwlock_t *rwptr);

以上三个基本函数返回值均：成功返回0，出错返回正的错误值； 

  1. #include<pthread.h>
  2. int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwptr);
  3. int pthread_rwlock_trywrlock(pthread_rwlock_t *rwptr);

返回值同上；
要注意的是，上面两个函数尝试获取一个读出锁或者写入锁，但是如果该锁不能马上获得，那就返回一个EBUSY错误，而不是把调用线程投入睡眠。


如何用互斥锁和条件变量实现读写锁呢？

以写锁优先为例：
先定义基本的pthread_rwlock_t数据类型和操做读写锁的各个函数的函数原型，即my_pthread_rwlock.h头文件； 
  1. #pragma once
  2.  
  3. #include<pthread.h>
  4. #include<stdio.h>
  5. #include<errno.h>
  6. #include<stdlib.h>
  7. typedef struct
  8. {
  9.     pthread_mutex_t rw_mutex;
  10.     pthread_cond_t  rw_condreaders;
  11.     pthread_cond_t  rw_condwriters;
  12.     int             rw_magic;
  13.     int             rw_nwaitreaders;
  14.     int             rw_nwaitwriters;
  15.     int             rw_refcount;       // 0 >0 ==-1
  16. }my_pthread_rwlock_t;
  17.  
  18. #define  RW_MAGIC  0x19960511  //魔法数，可修改
  19.  
  20. #define MY_PTHREAD_RWLOCK_INITIALIZER {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER,\
  21. RW_MAGIC,0,0,0}
  22.  
  23. typedef int  my_pthread_rwlockattr_t;
  24.  
  25.  
  26. int my_pthread_rwlock_init(my_pthread_rwlock_t *rw, my_pthread_rwlockattr_t *attr);
  27. int my_pthread_rwlock_destroy(my_pthread_rwlock_t *rw);
  28. int my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw);
  29. int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw);
  30. int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw);
  31. int my_pthread_rwlock_tryrdlock(my_pthread_rwlock_t *rw);
  32. int my_pthread_rwlock_trywrlock(my_pthread_rwlock_t *rw);

函数实现部分： 

  1. #include"my_pthread_rwlock.h"
  2.  
  3. int my_pthread_rwlock_init(my_pthread_rwlock_t *rw, my_pthread_rwlockattr_t *attr)
  4. {
  5.     int result;
  6.     if(attr != NULL)
  7.         return -1;
  8.  
  9.     if((result = pthread_mutex_init(&rw->rw_mutex, NULL)) != 0)
  10.         goto err1;
  11.     if((result = pthread_cond_init(&rw->rw_condreaders, NULL)) != 0)
  12.         goto err2;
  13.     if((result = pthread_cond_init(&rw->rw_condwriters, NULL)) != 0)
  14.         goto err3;
  15.  
  16.     rw->rw_nwaitreaders = 0;
  17.     rw->rw_nwaitwriters = 0;
  18.     rw->rw_refcount = 0;
  19.     rw->rw_magic = RW_MAGIC;
  20.     return 0;
  21.     
  22. err3:
  23.     pthread_cond_destroy(&rw->rw_condreaders);
  24. err2:
  25.     pthread_cond_destroy(&rw->rw_mutex);
  26. err1:
  27.     return result;
  28. }
  29.  
  30. int my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw)
  31. {
  32.     int result;
  33.     if(rw->rw_magic != RW_MAGIC)
  34.         return -1;
  35.     if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
  36.         return result;
  37.  
  38.     while(rw->rw_refcount<0 || rw->rw_nwaitwriters>0)//在有写锁的条件下等待
  39.     {
  40.         rw->rw_nwaitreaders++;
  41.         result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex);
  42.         rw->rw_nwaitreaders--;
  43.         if(result != 0)
  44.             break;
  45.     }
  46.     if(result == 0)
  47.         rw->rw_refcount++;
  48.     pthread_mutex_unlock(&rw->rw_mutex);
  49.     return result;
  50. }
  51.  
  52. int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)
  53. {
  54.     int result;
  55.     if(rw->rw_magic != RW_MAGIC)
  56.         return -1;
  57.  
  58.     if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
  59.         return result;
  60.  
  61.     while(rw->rw_refcount != 0)//有锁时等待
  62.     {
  63.         rw->rw_nwaitwriters++;
  64.         result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex);
  65.         rw->rw_nwaitwriters--;
  66.         if(result != 0)
  67.             break;
  68.     }
  69.     if(result == 0)
  70.         rw->rw_refcount = -1;
  71.  
  72.     pthread_mutex_unlock(&rw->rw_mutex);
  73.     return result;
  74. }
  75.  
  76. int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw)
  77. {
  78.     int result;
  79.     if(rw->rw_magic != RW_MAGIC)
  80.         return -1;
  81.     if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
  82.         return result;
  83.  
  84.     if(rw->rw_refcount > 0)
  85.         rw->rw_refcount--;
  86.     else if(rw->rw_refcount == -1)
  87.         rw->rw_refcount = 0;
  88.     else
  89.         printf("unlock error.\n");
  90.  
  91.     if(rw->rw_nwaitwriters > 0)//写锁优先
  92.     {
  93.         if(rw->rw_refcount == 0)
  94.         {
  95.             result = pthread_cond_signal(&rw->rw_condwriters);
  96.         }
  97.     }
  98.     else if(rw->rw_nwaitreaders > 0)//唤醒读锁
  99.         result = pthread_cond_broadcast(&rw->rw_condreaders);
  100.  
  101.     pthread_mutex_unlock(&rw->rw_mutex);
  102.     return result;
  103. }
  104.  
  105. int my_pthread_rwlock_tryrdlock(my_pthread_rwlock_t *rw)
  106. {
  107.     int result;
  108.     if(rw->rw_magic != RW_MAGIC)
  109.         return -1;
  110.     
  111.     if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
  112.         return result;
  113.  
  114.     if(rw->rw_refcount < 0 || rw->rw_nwaitwriters > 0)
  115.         result = EBUSY;
  116.     else
  117.         rw->rw_refcount++;
  118.  
  119.     pthread_mutex_unlock(&rw->rw_mutex);
  120.     return result;
  121. }
  122.  
  123. int my_pthread_rwlock_trywrlock(my_pthread_rwlock_t *rw)
  124. {
  125.     int result;
  126.     if(rw->rw_magic != RW_MAGIC)
  127.         return -1;
  128.  
  129.     if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
  130.         return result;
  131.  
  132.     if(rw->rw_refcount != 0)
  133.         result = EBUSY;
  134.     else
  135.         rw->rw_refcount = -1;
  136.  
  137.     pthread_mutex_unlock(&rw->rw_mutex);
  138.     return result;
  139. }
  140.  
  141. int my_pthread_rwlock_destroy(my_pthread_rwlock_t *rw)
  142. {
  143.     if(rw->rw_magic != RW_MAGIC)
  144.         return -1;
  145.     if(rw->rw_refcount != 0 || rw->rw_nwaitwriters != 0)
  146.         return EBUSY;
  147.  
  148.     pthread_mutex_destroy(&rw->rw_mutex);
  149.     pthread_cond_destroy(&rw->rw_condreaders);
  150.     pthread_cond_destroy(&rw->rw_condwriters);
  151.     rw->rw_magic = 0;
  152.  
  153.     return 0;
  154. }

再是测试程序： 

  1. #include<stdio.h>
  2. #include<unistd.h>
  3. #include<pthread.h>
  4. #include"my_pthread_rwlock.h"
  5.  
  6. my_pthread_rwlock_t rwlock = MY_PTHREAD_RWLOCK_INITIALIZER;
  7.  
  8. void * thread_fun1(void *arg)
  9. {
  10.     my_pthread_rwlock_wrlock(&rwlock);
  11.     printf("thread 1 wrlock.\n");
  12.     sleep(3);
  13.     my_pthread_rwlock_unlock(&rwlock);
  14. }
  15. void * thread_fun2(void *arg)
  16. {
  17.     my_pthread_rwlock_wrlock(&rwlock);
  18.     printf("thread 2 wrlock.\n");
  19.     my_pthread_rwlock_unlock(&rwlock);
  20. }
  21. void * thread_fun3(void *arg)
  22. {
  23.     my_pthread_rwlock_rdlock(&rwlock);
  24.     printf("thread 3 rdlock.\n");
  25.     my_pthread_rwlock_unlock(&rwlock);
  26. }
  27.  
  28. int main()
  29. {
  30.     pthread_t tid1, tid2, tid3;
  31.     pthread_create(&tid1, NULL, thread_fun1, NULL);
  32.     sleep(1);
  33.     pthread_create(&tid3, NULL, thread_fun3, NULL);
  34.     pthread_create(&tid2, NULL, thread_fun2, NULL);
  35.  
  36.     pthread_join(tid1, NULL);
  37.     pthread_join(tid2, NULL);
  38.     pthread_join(tid3, NULL);
  39.  
  40.     return 0;
  41. }

结果：
这样子一个写优先的读写锁就实现了，读优先的话也是同样原理的，只是部分代码的执行顺序和部分条件判定不同而已


事与冀盼又落差，请不必惊怕
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/336606?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号