17.线程同步：读写锁rwlock

1.读写锁

读锁：共享
写锁：独占
1.多个线程可以对同一个共享资源加[读锁]
2.但是只要有一个[写锁]到来，后面申请的锁全部会阻塞
3.写锁优先：防止[写操作]一直等待下去
	当已经加了读锁，此时再来了写锁请求，之后又来了读锁请求====>后面到来的读锁请求不能
请求成功，只有等到前面的写锁请求并写操作完成后，才能请求成功。

2.读写锁的使用场景

执行读操作的线程数 > 执行写操作的线程数

3.读写锁：相关函数

pthread_rdlock_t lock;//读写锁类型

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr); //初始化
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); //释放


int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); //加[读锁]
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); //尝试加[读锁]

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); //加[写锁]
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); //尝试加[写锁]

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); //解锁

案例

程序功能：
	3个线程不定时[写]同一个全局资源number，5个线程不定时[读]同一个全局资源number

  int number=0; // 全局资源                                                                                             
  pthread_rwlock_t lock; //因为只有一个资源，因此只需要一个rdlock
  void* write_func(void* arg){                                                                                                   
    while(1){                                                                                                                    
      pthread_rwlock_wrlock(&lock); //加[写]锁                                         
      number++;                                                                                                                  
      printf("====%dth thread %lu write: %d\n",(int)arg,pthread_self(),number);                                                  
      pthread_rwlock_unlock(&lock);                                                                                              
      usleep(500);                                                                                                               
    }                                                                                                                            
    return NULL;                                                                                                                 
  }                                                                                                                              
  void* read_func(void* arg){                                                                                                    
    while(1){                                                                                                                    
      pthread_rwlock_rdlock(&lock); //加[读]锁                                                                                              
      printf("     %dth thread %lu read: %d\n",(int)arg,pthread_self(),number);                                                  
      pthread_rwlock_unlock(&lock);                                                                                              
      usleep(500);                                                                                                               
    }                                                                                                                            
    return NULL;                                                                                                                 
  }          
    int main(){                                                                                                                    
    pthread_rwlock_init(&lock,NULL);                                                                                             
                                                                                                                                 
    pthread_t tid[8];                                                                                                            
                                                                                                                                 
    //创建3个写线程                                                              
    for(int i=0;i<3;i++){                                                                                                        
      pthread_create(&tid[i],NULL,write_func,(void*)i);                                                                          
    }                                                                                                                            
    //创建5个读线程                                                                                                       
    for(int i=3;i<8;i++){                                                                                                        
      pthread_create(&tid[i],NULL,read_func,(void*)i);                                                                           
    }                                                                                                                            
                                                                                                                                 
    for(int i=0;i<8;i++)                                                                                                         
      pthread_join(tid[i],NULL);                                                                                                 
                                                                                                       
    pthread_rwlock_destroy(&lock);                                                                                               
    return 0;
  }                     
  程序执行结果：从上到下，数字肯定是递增的。