Linux C/C++编程：读写锁

港控/mmm° 2022-12-23 07:05 105阅读 0赞

> 读锁也叫做”共享锁“，写锁叫做”独占锁“

# 读写锁 #

## API ##

如何操作锁

#include <pthread.h>
    /*
    * 获取一个读锁：
    * 	* 如果该锁正在写，阻塞调用线程
    */
    int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
    
    
    /*
    * 获取一个写锁：
    * 	* 如果该锁正在写，阻塞调用线程
    *   * 如果该锁正在读，阻塞调用线程
    */
    int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
    
    /*
     * 释放读锁或者写锁
    */
    int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
    
    /*
    * 试图获取一个读锁：
    * 	* 如果该锁正在写，立刻返回EBUSY，而不是阻塞
    */
    int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
    /*
    * 试图获取一个写锁：
    * 	* 如果该锁正在写，立刻返回EBUSY，而不是阻塞
    */
    int pthread_rwlock_trywdlock (pthread_rwlock_t *__rwlock)

在获取锁之前我们必须初始化

// 静态初始化
    pthread_rwlock_t	rwlock = PTHREAD_RWLOCK_INITIALIZER;
    //动态初始化， attr为null时默认属性
    int pthread_rwlock_init(pthread_rwlock_t *rwptr, const pthread_rwlockattr_t *attr);
    int pthread_rwlock_destroy(pthread_rwlock_t *rwptr);

在释放某个读写锁占用的内存之前，要先通过`pthread_rwlock_destroy`对读写锁进行清理，释放由`pthread_rwlock_init`所分配的资源。在初始化某个读写锁的时候，如果属性指针attr是个空指针的话，表示默认的属性；如果想要使用非默认属性，则要使用到下面的两个函数：

#include 
     int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
     int pthread_rwlockattr_destroy(pthread_rwlockatttr_t *attr);

如果我们相要在不同进程间共享锁，可以通过下面函数设置属性`PTHREAD_PROCESS_SHARED`

int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
    					  __restrict __attr,
    					  int *__restrict __pshared)
    int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
    					  int __pshared)

## 测试 ##

1.  从下面可以看出：一个正在读的线程允许其他线程读，但是不许写；一个正在写的线程不允许其他写着，也不允许其他读者

#include <zconf.h>
    #include <pthread.h>
    #include <stdlib.h>
    #include <stdio.h>
    
    
    #define	MAXNTHREADS	100
    
    void	*reader(void *), *writer(void *);
    
    int		nloop = 1000, nreaders = 6, nwriters = 4;
    
    struct {
        
        pthread_rwlock_t	rwlock;
        pthread_mutex_t	rcountlock;
        int				nreaders;
        int				nwriters;
    } shared = {
         PTHREAD_RWLOCK_INITIALIZER, PTHREAD_MUTEX_INITIALIZER };
    
    int
    main(int argc, char **argv)
    {
        
        int		c, i;
        pthread_t	tid_readers[MAXNTHREADS], tid_writers[MAXNTHREADS];
    
        while ( (c = getopt(argc, argv, "n:r:w:")) != -1) {
        
            switch (c) {
        
                case 'n':
                    nloop = atoi(optarg);
                    break;
    
                case 'r':
                    nreaders = atoi(optarg);
                    break;
    
                case 'w':
                    nwriters = atoi(optarg);
                    break;
            }
        }
        if (optind != argc){
        
            printf("usage: test1 [-n #loops ] [ -r #readers ] [ -w #writers ]");
            exit(0);
        }
            
    
        /* 4create all the reader and writer threads */
        for (i = 0; i < nreaders; i++)
            pthread_create(&tid_readers[i], NULL, reader, NULL);
        for (i = 0; i < nwriters; i++)
            pthread_create(&tid_writers[i], NULL, writer, NULL);
    
        /* wait for all the threads to complete */
        for (i = 0; i < nreaders; i++)
            pthread_join(tid_readers[i], NULL);
        for (i = 0; i < nwriters; i++)
            pthread_join(tid_writers[i], NULL);
    
        exit(0);
    }
    
    void * reader(void *arg)
    {
        
        int		i;
    
        for (i = 0; i < nloop; i++) {
        
            pthread_rwlock_rdlock(&shared.rwlock);
    
            pthread_mutex_lock(&shared.rcountlock);
            shared.nreaders++;	/* shared by all readers; must protect */
            pthread_mutex_unlock(&shared.rcountlock);
    
            if (shared.nwriters > 0) {
        //当读时不允许其他人写 （但是可以读）
                printf("reader: %d writers found", shared.nwriters);
                exit(0);
            } 
                
    
            pthread_mutex_lock(&shared.rcountlock);
            shared.nreaders--;	/* shared by all readers; must protect */
            pthread_mutex_unlock(&shared.rcountlock);
    
            pthread_rwlock_unlock(&shared.rwlock);
        }
        return(NULL);
    }
    
    void *writer(void *arg)
    {
        
        int		i;
    
        for (i = 0; i < nloop; i++) {
        
            pthread_rwlock_wrlock(&shared.rwlock);
            shared.nwriters++;	/* only one writer; need not protect */
    
            if (shared.nwriters > 1) {
        //当写的时候不允许其他人写
                printf("writer: %d writers found", shared.nwriters);
                exit(0);
            } 
                
            if (shared.nreaders > 0) {
        // 当写的时候不允许其他人读
                printf("writer: %d readers found", shared.nreaders);
                exit(0);
            }
                
    
            shared.nwriters--;	/* only one writer; need not protect */
            pthread_rwlock_unlock(&shared.rwlock);
        }
        return(NULL);
    }

1.  计数：

*  从下面可以看出，并不是并不是多线程就一定好，由于有很多的线程在抢锁，所以它反而不如单线程
 *  我们可以关注的是：如果想要所有线程站在同一个起点上，我们可以主线程在创建线程之前先上锁（这个锁主线程和其他子线程共享），等待所有线程都创建完成之后，才释放锁

#include <stdio.h>
    #include <pthread.h>
    #include <stdlib.h>
    #include <unpipc.h>
    #define	MAXNTHREADS	100
    
    int		nloop;
    
    struct {
        
        pthread_rwlock_t	rwlock;
        long	counter;
    } shared = {
         PTHREAD_RWLOCK_INITIALIZER };
    
    void	*incr(void *);
    
    int main(int argc, char **argv)
    {
        
        int		i, nthreads;
        pthread_t	tid[MAXNTHREADS];
    
        if (argc != 3){
        
            printf("usage: incr_rwlock1 <#loops> <#threads>");
            exit(0);
        }
    
        nloop = atoi(argv[1]);
        nthreads = min(atoi(argv[2]), MAXNTHREADS);
    
    
        pthread_rwlock_wrlock(&shared.rwlock);
        for (i = 0; i < nthreads; i++) {
        
            pthread_create(&tid[i], NULL, incr, NULL);
        }
        start_time();
        pthread_rwlock_unlock(&shared.rwlock);
    
        for (i = 0; i < nthreads; i++) {
        
            pthread_join(tid[i], NULL);
        }
        printf("microseconds: %.0f usec\n", stop_time());
        if (shared.counter != nloop * nthreads)
            printf("error: counter = %ld\n", shared.counter);
    
        exit(0);
    }
    
    void *incr(void *arg)
    {
        
        int		i;
    
        for (i = 0; i < nloop; i++) {
        
            pthread_rwlock_wrlock(&shared.rwlock);
            shared.counter++;
            pthread_rwlock_unlock(&shared.rwlock);
        }
        return(NULL);
    }

![在这里插入图片描述][20201124115641100.png_pic_center]

# 使用互斥量和条件变量实现读写锁 #

## 实现1： 写优先（第一版） ##

### 实现 ###

1.  定义数据类型

#include <pthread.h>
    #include <asm/errno.h>
    #include <stdio.h>
    typedef struct {
        
        pthread_mutex_t	rw_mutex;		/* basic lock on this struct */
        pthread_cond_t	rw_condreaders;	/* for reader threads waiting */
        pthread_cond_t	rw_condwriters;	/* for writer threads waiting */
        int				rw_magic;		/* for error checking: 该结构初始化成功之后， rw_magic就被设置为RW_MAGIC， 该读写锁被销毁之后，这个成员就被置0*/
        int				rw_nwaitreaders;/* the number waiting */
        int				rw_nwaitwriters;/* the number waiting */
        int				rw_refcount;  // 指示着本读写锁的当前状态：-1表示它是一个写入锁（任何时刻这样的锁只能有一个），0表示它是可用的，大于0表示它当前容纳着那么多的读出锁
        /* 4-1 if writer has the lock, else # readers holding the lock */
    } my_pthread_rwlock_t;
    
    typedef	int		my_pthread_rwlockattr_t;	/* dummy; not supported */
    
    #define	RW_MAGIC	0x19283746
    
    
    #define	PTHREAD_RWLOCK_INITIALIZER	{ PTHREAD_MUTEX_INITIALIZER, \
    			PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER, \
    			RW_MAGIC, 0, 0, 0 }   // 用于静态初始化

1.  动态初始化一个读写锁

int my_pthread_rwlock_init(my_pthread_rwlock_t *rw, my_pthread_rwlockattr_t *attr)
    {
        
        int		result;
    
        if (attr != NULL)  // 不支持给读写锁赋予属性，所以attr必须为null
            return(EINVAL);		/* not supported */
    
        if ( (result = pthread_mutex_init(&rw->rw_mutex, NULL)) != 0)
            goto err1;
        if ( (result = pthread_cond_init(&rw->rw_condreaders, NULL)) != 0)
            goto err2;
        if ( (result = pthread_cond_init(&rw->rw_condwriters, NULL)) != 0)
            goto err3;
        rw->rw_nwaitreaders = 0;
        rw->rw_nwaitwriters = 0;
        rw->rw_refcount = 0;
        rw->rw_magic = RW_MAGIC;  // RW_MAGIC表示该结构已经初始化完毕了
    
        return(0);
    
        err3:
        pthread_cond_destroy(&rw->rw_condreaders);
        err2:
        pthread_mutex_destroy(&rw->rw_mutex);
        err1:
        return(result);			/* an errno value */
    }
    /* end init */
    
    void Pthread_rwlock_init(my_pthread_rwlock_t *rw, my_pthread_rwlockattr_t *attr)
    {
        
        int		n;
    
        if ( (n = my_pthread_rwlock_init(rw, attr)) == 0)
            return;
    
        printf("pthread_rwlock_init error, %d", n);
    }

1.  销毁一个读写锁

int my_pthread_rwlock_destroy(my_pthread_rwlock_t *rw)
    {
        
        if (rw->rw_magic != RW_MAGIC)
            return(EINVAL);
        if (rw->rw_refcount != 0 || rw->rw_nwaitreaders != 0 || rw->rw_nwaitwriters != 0)  // 检查是不是还有人在使用这个锁
            return(EBUSY);
    
        pthread_mutex_destroy(&rw->rw_mutex);
        pthread_cond_destroy(&rw->rw_condreaders);
        pthread_cond_destroy(&rw->rw_condwriters);
        rw->rw_magic = 0;
    
        return(0);
    }
    
    
    void Pthread_rwlock_destroy(my_pthread_rwlock_t *rw)
    {
        
        int		n;
    
        if ( (n = my_pthread_rwlock_destroy(rw)) == 0)
            return;
    
    
        printf("pthread_rwlock_destroy error, %d", n);
    }

1.  上读锁

/*
    * 实现了功能：
    * 	如果有线程正在读而且没有线程正在等待写， 读锁可以直接加
    * 	如果有线程正在写或者有现在正在等待写，读锁阻塞等待
    * 	
    */
    int my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw)
    {
        
        int		result;
    
        if (rw->rw_magic != RW_MAGIC)  // 该结构体没有初始化
            return(EINVAL);
    
        if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)  // 无论什么时候操作my_pthread_rwlock_t，rw_mutex必须先上锁
            return(result);
    
        /* 写优先 */
        while (rw->rw_refcount < 0 || rw->rw_nwaitwriters > 0) {
                    // 有线程正在写 | 有线程正等着获取一个写入锁
            rw->rw_nwaitreaders++;                                          //  等待加1
            result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex); // 并且将当前线程加到等待队列中,然后解锁（某个线程被唤醒了会自动加锁）,唤醒条件是rw->rw_condreaders信号被发送，那么什么时候rw->rw_condreaders信号被发送呢：当一个读写锁解锁时，会先检查是不是有线程在等待写，如果没有，再检查是不是有线程在等待读，如果有，则向rw->rw_condreaders条件变量广播信号
            rw->rw_nwaitreaders--;                                          // 有一个线程被唤醒了(自动加锁)，等待减1
            if (result != 0)                                               // 如果是意外退出，直接跳出当前循环，否则接着循环查看是不是已经有人在写了(while)
                break;
        }
        if (result == 0)                    
            rw->rw_refcount++;		/* another reader has a read lock */
    
        pthread_mutex_unlock(&rw->rw_mutex);
        return (result);
    }
    
    void Pthread_rwlock_rdlock(my_pthread_rwlock_t *rw)
    {
        
        int		n;
    
        if ( (n = my_pthread_rwlock_rdlock(rw)) == 0)
            return;
        printf("pthread_rwlock_rdlock error, %d", n);
    }

1.  尝试上读锁

int my_pthread_rwlock_tryrdlock(my_pthread_rwlock_t *rw)
    {
        
        int		result;
    
        if (rw->rw_magic != RW_MAGIC)  // 结构体没有初始化
            return(EINVAL);
    
        if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)  // 无论什么时候操作my_pthread_rwlock_t，rw_mutex必须先上锁
            return(result);
    
        if (rw->rw_refcount < 0 || rw->rw_nwaitwriters > 0)  // 有线程正在写 | 有线程正等着获取一个写入锁
            result = EBUSY;			/* held by a writer or waiting writers */
        else                       
            rw->rw_refcount++;		/* 读者加1  */
    
        pthread_mutex_unlock(&rw->rw_mutex);
        return(result);
    }
    
    int Pthread_rwlock_tryrdlock(my_pthread_rwlock_t *rw)
    {
        
        int		n;
    
        if ( (n = my_pthread_rwlock_tryrdlock(rw)) != 0) {
        
            printf("pthread_rwlock_tryrdlock error, %d", n);
        }
        return(n);
    }

1.  上写锁

int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)
    {
        
        int		result;
    
        if (rw->rw_magic != RW_MAGIC)  // 结构体没有初始化
            return(EINVAL);
    
        if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)  // 无论什么时候操作my_pthread_rwlock_t，rw_mutex必须先上锁:因为这个锁会被很多线程共享
            return(result);
    
        while (rw->rw_refcount != 0) {
          // 如果要上写锁，必须是当前锁没有正在读/写，否则当前现在就会阻塞等待被唤醒
            rw->rw_nwaitwriters++;
            result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex); // 解锁并等待唤醒， 什么时候rw->rw_condwriters信号被发送：当前读写锁被释放时，会检查是不是有线程正在等待写，如果有，就发送信号
            rw->rw_nwaitwriters--;
            if (result != 0)
                break;
        }
        if (result == 0)
            rw->rw_refcount = -1;  //标识当前读写锁被一个写锁获取到了
    
        pthread_mutex_unlock(&rw->rw_mutex);
        return(result);
    }
    
    
    void Pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)
    {
        
        int		n;
    
        if ( (n = my_pthread_rwlock_wrlock(rw)) == 0)
            return;
        printf("pthread_rwlock_wrlock error, %d", n);
    }

1.  非阻塞版本的上写锁

int my_pthread_rwlock_trywrlock(my_pthread_rwlock_t *rw)
    {
        
        int		result;
    
        if (rw->rw_magic != RW_MAGIC)
            return(EINVAL);
    
        if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
            return(result);
    
        if (rw->rw_refcount != 0)
            result = EBUSY;			/* held by either writer or reader(s) */
        else
            rw->rw_refcount = -1;	/* available, indicate a writer has it */
    
        pthread_mutex_unlock(&rw->rw_mutex);
        return(result);
    }
    int Pthread_rwlock_trywrlock(my_pthread_rwlock_t *rw)
    {
        
        int		n;
    
        if ( (n = my_pthread_rwlock_trywrlock(rw)) != 0) {
        
            printf("pthread_rwlock_trywrlock error, %d", n);
        }
        return(n);
    }

1.  解锁

int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw)
    {
        
        int		result;
    
        if (rw->rw_magic != RW_MAGIC)
            return(EINVAL);
    
        if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
            return(result);
    
        if (rw->rw_refcount > 0)
            rw->rw_refcount--;			/* releasing a reader */
        else if (rw->rw_refcount == -1)
            rw->rw_refcount = 0;		/* releasing a reader */
        else
            printf("rw_refcount = %d", rw->rw_refcount);
    
    
        if (rw->rw_nwaitwriters > 0) {
         // 有等待写的人
            if (rw->rw_refcount == 0)  //这个也可以注释掉
                result = pthread_cond_signal(&rw->rw_condwriters);
        } else if (rw->rw_nwaitreaders > 0)  //有人等待写
            result = pthread_cond_broadcast(&rw->rw_condreaders);
    
        pthread_mutex_unlock(&rw->rw_mutex);
        return(result);
    }
    void Pthread_rwlock_unlock(my_pthread_rwlock_t *rw)
    {
        
        int		n;
    
        if ( (n = my_pthread_rwlock_unlock(rw)) == 0)
            return;
        printf("pthread_rwlock_unlock error, %d", n);
    }

### 测试 ###

my_pthread_rwlock_t	rwlock = PTHREAD_RWLOCK_INITIALIZER;
    void	 *thread1(void *), *thread2(void *);
    pthread_t	tid1, tid2;
    
    int main(int argc, char **argv)
    {
        
        void	*status;
        Pthread_rwlock_init(&rwlock, NULL);
    
        pthread_create(&tid1, NULL, thread1, NULL);
        sleep(1);		/* let thread1() get the lock */
        pthread_create(&tid2, NULL, thread2, NULL);
    
        pthread_join(tid2, &status);
        if (status != PTHREAD_CANCELED){
        
            printf("thread2 status = %p\n", status);
        }else{
        
            printf("thread2 cancel status = %p\n", status);
        }
    
        pthread_join(tid1, &status);
        if (status != NULL){
        
            printf("thread1 status = %p\n", status);
        }else{
        
            printf("thread1 exit status = %p\n", status);
        }
    
    
        printf("rw_refcount = %d, rw_nwaitreaders = %d, rw_nwaitwriters = %d\n",
               rwlock.rw_refcount, rwlock.rw_nwaitreaders,
               rwlock.rw_nwaitwriters);
        Pthread_rwlock_destroy(&rwlock);
        /* 4returns EBUSY error if cancelled thread does not cleanup */
    
        return 0;
    }
    
    void *thread1(void *arg)
    {
        
        Pthread_rwlock_rdlock(&rwlock);
        printf("thread1() got a read lock\n");
        sleep(3);		/* let thread2 block in pthread_rwlock_wrlock() */
        pthread_cancel(tid2);
        sleep(3);
        printf("thread1() will realease a read lock\n");
        Pthread_rwlock_unlock(&rwlock);
        printf("thread1() had realease a read lock\n");
        return(NULL);
    }
    
    void * thread2(void *arg)
    {
        
        printf("thread2() trying to obtain a write lock\n");
        Pthread_rwlock_wrlock(&rwlock);
        printf("thread2() got a write lock\n");
        sleep(1);
        Pthread_rwlock_unlock(&rwlock);
        return(NULL);
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center]  
如果我们注释掉thread1中的`Pthread_rwlock_unlock(&rwlock);`，可以看到：  
![在这里插入图片描述][20201124111010987.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center 1]  
如何解决上面的问题(当然，读锁也有这样的问题)，见实现2

## 实现2： 写优先（解决cancel问题） ##

除了”上写锁“，”上读锁“这两个意外，其余和1相同

1.  上读锁

static void rwlock_cancelrdwait_rd(void *arg)
    {
        
        my_pthread_rwlock_t	*rw;
    
        rw = arg;
        rw->rw_nwaitreaders--;
        pthread_mutex_unlock(&rw->rw_mutex);
    }
    int my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw)
    {
        
        int		result;
    
        if (rw->rw_magic != RW_MAGIC)
            return(EINVAL);
    
        if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
            return(result);
    
    
        while (rw->rw_refcount < 0 || rw->rw_nwaitwriters > 0) {
        
            rw->rw_nwaitreaders++;
            pthread_cleanup_push(rwlock_cancelrdwait_rd, (void *) rw);  // 如果是不正常退出，将会调用rwlock_cancelrdwait_rd
            result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex);
            pthread_cleanup_pop(0); // 如果是正常退出，0参数就不会调用rwlock_cancelrdwait_rd
            rw->rw_nwaitreaders--;
            if (result != 0)
                break;
        }
        if (result == 0)
            rw->rw_refcount++;		
    
        pthread_mutex_unlock(&rw->rw_mutex);
        return (0);
    }
    
    void Pthread_rwlock_rdlock(pthread_rwlock_t *rw)
    {
        
        int		n;
    
        if ( (n = pthread_rwlock_rdlock(rw)) == 0)
            return;
        printf("pthread_rwlock_rdlock error");
    }

1.  上写锁

static void rwlock_cancelwrwait_wr(void *arg)
    {
        
        my_pthread_rwlock_t	*rw;
    
        rw = arg;
        rw->rw_nwaitwriters--;
        pthread_mutex_unlock(&rw->rw_mutex);
    }
    /* end rwlock_cancelwrwait */
    
    int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)
    {
        
        int		result;
    
        if (rw->rw_magic != RW_MAGIC)
            return(EINVAL);
    
        if ( (result = pthread_mutex_lock(&rw->rw_mutex)) == -1)
            return(result);
    
        while (rw->rw_refcount != 0) {
        
            rw->rw_nwaitwriters++;
            pthread_cleanup_push(rwlock_cancelwrwait_wr, (void *) rw);
                    result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex);
            pthread_cleanup_pop(0);
            rw->rw_nwaitwriters--;
            if (result != 0)
                break;
        }
        if (result == 0)
            rw->rw_refcount = -1;
    
        pthread_mutex_unlock(&rw->rw_mutex);
        return(0);
    }
    /* end func */
    
    void Pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)
    {
        
        int		n;
    
        if ( (n = my_pthread_rwlock_wrlock(rw)) == 0)
            return;
        printf("pthread_rwlock_wrlock error");
    }

## 实现3：读优先 ##

读优先很简单，只需要修改解锁时发送信号的顺序就可以了，其他与实现2相同

int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw)
    {
        
        int		result;
    
        if (rw->rw_magic != RW_MAGIC)
            return(EINVAL);
    
        if ( (result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
            return(result);
    
        if (rw->rw_refcount > 0)
            rw->rw_refcount--;			/* releasing a reader */
        else if (rw->rw_refcount == -1)
            rw->rw_refcount = 0;		/* releasing a reader */
        else
            printf("rw_refcount = %d", rw->rw_refcount);
    
        if (rw->rw_nwaitreaders > 0){
          //有人等待写
            result = pthread_cond_broadcast(&rw->rw_condreaders);
        }else if (rw->rw_nwaitwriters > 0) {
         // 有等待写的人
                result = pthread_cond_signal(&rw->rw_condwriters);
        }   
    
        pthread_mutex_unlock(&rw->rw_mutex);
        return(result);
    }
    void Pthread_rwlock_unlock(my_pthread_rwlock_t *rw)
    {
        
        int		n;
    
        if ( (n = my_pthread_rwlock_unlock(rw)) == 0)
            return;
        printf("pthread_rwlock_unlock error, %d", n);
    }

[20201124115641100.png_pic_center]: /images/20221120/06461a325830443ab9c703e2e28f47ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/87b4fe4883cb442582b34fc36da4efce.png
[20201124111010987.png_pic_center]: /images/20221120/ad542a4d7358497bb8a501ba83353014.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/ab7ec91689ca44c2abe8f80918a8911b.png