Linux--读写锁

 读共享,写独享,写锁优先级高

POSIX 定义的读写锁的数据类型是: pthread_rwlock_t

1、初始化读写锁

#include<pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);

可以使用宏 PTHREAD_RWLOCK_INITIALIZER 静态初始化读写锁，比如:
pthread_rwlock_t my_rwlock = PTHREAD_RWLOCK_INITIALIZER;
这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_rwlock_init() 来完成动态初始化，不同之处在于PTHREAD_RWLOCK_INITIALIZER 宏不进行错误检查。

功能:
        用来初始化 rwlock 所指向的读写锁。
参数:
        rwlock:指向要初始化的读写锁指针。
        attr:读写锁的属性指针。如果 attr 为NULL 则会使用默认的属性初始化读写锁，否则
              使用指定的 attr 初始化读写锁。
返回值:
        成功:0，读写锁的状态将成为已初始化和已解锁。
        失败:非 0 错误码

2、释放读写锁

#include<pthread.h>
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

功能:
        用于销毁一个读写锁，并释放所有相关联的资源(所谓的所有指的是由pthread_rwlock_init()
        自动申请的资源) 。
参数:
        rwlock:读写锁指针。
返回值:
        成功:0
        失败:非 0 错误码

3、申请读锁

#include<pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

功能:
        以阻塞方式在读写锁上获取读锁(读锁定)。
        如果没有写者持有该锁，并且没有写者阻塞在该锁上，则调用线程会获取读锁。
        如果调用线程未获取读锁，则它将阻塞直到它获取了该锁。一个线程可以在一个读写锁上多次执行
        读锁定。线程可以成功调用 pthread_rwlock_rdlock() 函数n 次，但是之后该线程必须调用
        pthread_rwlock_unlock() 函数 n 次才能解除锁定。
参数:
        rwlock:读写锁指针。
返回值:
        成功:0
        失败:非 0 错误码

4、申请写锁

#include<pthread.h>
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

功能:
        在读写锁上获取写锁(写锁定)。
        如果没有写者持有该锁，并且没有写者读者持有该锁，则调用线程会获取写锁。
        如果调用线程未获取写锁，则它将阻塞直到它获取了该锁。
参数:
        rwlock:读写锁指针。
返回值:
        成功:0
        失败:非 0 错误码

5、释放读写锁

#include<pthread.h>
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

功能:
        无论是读锁或写锁，都可以通过此函数解锁。
参数:
        rwlock:读写锁指针。
返回值:
        成功:0
        失败:非 0 错误码

示例代码

#include<stdio.h>
#include<pthread.h>
#include<unistd.h> 
//定义一把锁
pthread_rwlock_t rwlock; 

 void* read_data01(void* arg)
{
        int *p = (int *)arg;
         while (1)
         {
                //申请上读锁
                pthread_rwlock_rdlock(&rwlock);
                printf("任务A:num=%d\n", *p);
                //解读写锁
                pthread_rwlock_unlock(&rwlock);
                sleep(1); 
         }
         return NULL;
}

void* read_data02(void* arg)
{
     int *p = (int *)arg;
    while (1)
    {
         //申请上读锁
         pthread_rwlock_rdlock(&rwlock);
         printf("任务B:num=%d\n", *p); 
         //解读写锁 
         pthread_rwlock_unlock(&rwlock);
         sleep(1);
       } 
    return NULL; 
 }

void* write_data(void* arg)
{ 
    int *p = (int *)arg;
    while (1)
   {
       //申请写锁 
      pthread_rwlock_wrlock(&rwlock); 
      (*p)++; 
      //解读写锁 
      pthread_rwlock_unlock(&rwlock); 
      printf("任务C:写入num=%d\n", *p); 
      sleep(2); 
      } 
      return NULL; 
 }

int main(int argc,char const*argv[]) 
{ 
     //定义一个公共资源
     int num = 0;
     //初始化一把锁
    pthread_rwlock_init(&rwlock, NULL);
     //创建两个线程
    pthread_t tid1, tid2, tid3;
    pthread_create(&tid1, NULL, read_data01, (void *)&num);//读
    pthread_create(&tid2, NULL, read_data02, (void *)&num);//读
    pthread_create(&tid3, NULL, write_data, (void *)&num);//写
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    //销毁锁   
    pthread_rwlock_destroy(&rwlock); 
    return 0; 
}