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;
  }                     
  程式執行結果：從上到下，數字肯定是遞增的。