16.线程同步：互斥锁mutex

1.案例：两个线程分别对一个变量，都++操作1000次

1.实际的执行结果：number的最终值<2000
2.数据混乱的原因：
	多个线程操作了共享资源
	CPU调度问题	
3.解决：线程同步
  int number=0;                                                                                                                  
  void* FUNC1(void* arg){                                                                                                        
    for(int i=0;i<1000;i++){                                                                                                     
      printf("A:%d\n",number++);                                                                                                 
      usleep(1);                                                                                                                 
    }                                                                                                                            
  }                                                                                                                              
  void* FUNC2(void* arg){                                                                                                        
    for(int i=0;i<1000;i++){                                                                                                     
      printf("B:%d\n",number++);                                                                                                 
      usleep(1);                                                                                                                 
    }                                                                                                                            
  }                                                                                                                              
  int main(){                                                                                                                    
    pthread_t tid1,tid2;                                                                                                         
    pthread_create(&tid1,NULL,FUNC1,NULL);                                                                                       
    pthread_create(&tid2,NULL,FUNC2,NULL);                                                                                       
                                                                                                                                 
    pthread_join(tid1,NULL);                                                                                                     
    pthread_join(tid2,NULL);                                                                                                     
                                                                                                                                 
    return 0;                                                                                                                    
  }   

2.互斥锁：相关函数

pthread_mutex_t mutex //互斥锁类型

int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr); //初始化互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);//销毁互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int pthread_mutex_lock(pthread_mutex_t *mutex); //如果加锁的时候发现锁已经被锁上，线程会一直阻塞
int pthread_mutex_trylock(pthread_mutex_t *mutex); //尝试加锁，失败返回，不阻塞
int pthread_mutex_unlock(pthread_mutex_t *mutex);  //解锁

案例代码修改：使用mutex进行同步访问全局变量number

pthread_mutex_t mutex; 
int number=0;                                                                                                                  
void* FUNC1(void* arg){                                                                                                        
  for(int i=0;i<1000;i++){                                                                                                     
    pthread_mutex_lock(&mutex);                                                                                                
    printf("A:%d\n",number++);                                                                                                 
    usleep(1);                                                                                                                 
    pthread_mutex_unlock(&mutex);                                                                                              
  }                                                                                                                            
}                                                                                                                              
void* FUNC2(void* arg){                                                                                                        
  for(int i=0;i<1000;i++){                                                                                                     
    pthread_mutex_lock(&mutex);                                                                                                
    printf("B:%d\n",number++);                                                                                                 
    usleep(1);                                                                                                                 
    pthread_mutex_unlock(&mutex);                                                                                              
  }                                                                                                                            
}                                                                                                                              
int main(){                                                                                                                    
  pthread_mutex_init(&mutex,NULL);                                                                                             
                                                                                                                               
  pthread_t tid1,tid2;                                                                                                         
                                                                                                                               
  pthread_create(&tid1,NULL,FUNC1,NULL);                                                                                       
  pthread_create(&tid2,NULL,FUNC2,NULL);                                                                                       
                                                                                                                               
  pthread_join(tid1,NULL);                                                                                                     
  pthread_join(tid2,NULL);                                                                                                     
                                                                                                                               
  pthread_mutex_destroy(&mutex);                                                                                               
  return 0;                                                                                                                    
}