互斥锁保证每时刻每个用户看到的共享数据是一样的。只有lock与unlock两种状态，确保同一时间只有一个线程访问数据。
 
在同一时间通常只允许一个线程执行部分代码。
 
使用互斥锁前必须进行初始化操作。
 
(1)pthread_mutex_t = PTHREAD_MUTEX_INITIALIZER;
 
(2)int pthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
 

 
 
互斥锁锁住的并不是一个变量，而是阻塞一段程序。如果对一个mutex变量执行了第一次lock之后，在unlock前的这短时间内，如果有其他线程也只行到了lock，这个线程就会阻塞住，知道之前的lock解锁之后才能执行。
 

 
 
加锁：
 
int pthread_mutex_lock(pthread_mutex_t  *mutex);
 
int pyhread_mutex_trylock(pthread_mutex_t  *mutex);
 
若mutex已经被加锁则lock会等带其解锁再加锁运行后面的程序，而trylock若遇到mutex以加锁则立即返回返回的错误代码为EBUSY，而不是阻塞等待。
 

 
 
解锁：
 
int pthread_mutex_unlock(pthread_mutex_t  *mutex);
 
解锁时需要满足两个条件，一时互斥锁处于加锁状态，二是调用unlock的线程必须是给互斥锁加锁的线程;
 

 
 
int pthread_thread_delete(pthread_mutex_destory);
 
清楚一个互斥锁意味着释放其占有的资源清除锁时要求当前处于开放状态。

通过以下代码可以看到互斥锁的重要性：
 
#include <stdio.h>
 
#include <unistd.h>
 #include <pthread.h>
 
 
 static int totalmoney = 20000;   //总金额20000
 
 
 pthread_mutex_t mutex ; //定义变量
 
 
 int Check_balance()
 {
 return totalmoney;
 }
 
 
 void Save_money(int samoney)
 {
 int surplus;
 while(1)
 {
 //pthread_mutex_lock( &mutex ) ; //@a1，锁定mutex指向的互斥锁
 surplus = Check_balance();
 sleep(1);
 
 totalmoney = surplus + samoney;
 printf("After save money current balance is %d\n",totalmoney);
 //pthread_mutex_unlock( &mutex ) ; //@a1，给mutex指向的互斥锁解锁
 sleep(1);
 }
 }
 
 
 void Draw_money(int gemoney)
 {
 while(1)
 {
 //pthread_mutex_lock( &mutex ) ; //@a2，锁定mutex指向的互斥锁
 
 totalmoney = totalmoney - gemoney;
 printf("After draw money current balance is %d\n",totalmoney);
 sleep(1);
 
 //pthread_mutex_unlock( &mutex ) ; //@a2，给mutex指向的互斥锁解锁
 }
 }
 
 
 int main()
 {
 pthread_t thread1,thread2;
 int ret1,ret2;
 int samoney = 5000;   //存款金额
 int gemoney = 10000;   //取款金额
 
 pthread_mutex_init( &mutex , NULL ) ;  //初始化互斥锁
 
 printf("Total money in the account is %d\n\n",totalmoney);
 ret1 = pthread_create(&thread1,NULL,(void *)Save_money,(void *)samoney);
 if(ret1)
 {
 fprintf(stdout,"Create thread failed!\n");
 return -1;
 }
 sleep(2);
 ret2 = pthread_create(&thread2,NULL,(void *)Draw_money,(void *)gemoney);
 
 if(ret2)
 {
 fprintf(stdout,"Create thread failed!\n");
 return -1;
 }
 
 sleep(4);
 return 0;
  
}
 
取消@a1、@a2处的互斥锁（即不使用互斥锁）时其中又一次的结果如下：
 
 
Total money in the account is 20000
 
 
 After save money current balance is 25000
 After draw money current balance is 15000
 After save money current balance is 20000
 After draw money current balance is 10000
 After draw money current balance is 0
 After save money current balance is 15000
 After draw money current balance is 5000
 
 
 Total money in the account is 5000
 
 
总共存了3次（共15000），取了4次（共40000），这样就只赚（赚了10000）不赔了，要是银行都这样就好了，呵呵~~~
 

 
 
在@a1、@a2处加上互斥锁（即使用互斥锁）时其中又一次的结果如下：
 
 
Total money in the account is 20000
 
 
 After save money current balance is 25000
 After draw money current balance is 15000
 After save money current balance is 20000
 After draw money current balance is 10000
 
 
 Total money in the account is 10000
 
 
总共存了2次（共10000），取了2次（共20000），这样就谁都不会亏了~~~
 

 
 
互斥锁解决了线程不同步问题
 

 

互斥锁
 
 
 
线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。互斥锁为资源引入一个状态：锁定/非锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性
 
 
1、互斥锁基本原理：
 互斥锁是一个二元变量，其状态为开锁(允许0)和上锁(禁止1)，将某个共享资源与某个特定互斥锁在逻辑上绑定(要申请该资源必须先获取锁)。
 (1)访问公共资源前，必须申请该互斥锁，若处于开锁状态，则申请到锁对象，并立即占有该锁，以防止其他线程访问该资源；如果该互斥锁处于锁定状态，则阻塞当前线程。
 (2)只有锁定该互斥锁的进程才能释放该互斥锁，其他线程试图释放无效。
 
2、初始化互斥锁：
 使用之前，需要定义互斥锁，使用函数：pthread_mutex_t lock;进行定义
 
extern int    pthread_mutex_init(pthread_mutex_t * **_mutex**,_const pthread_mutex_mutexattr_t*  **_mutexattr**)
 
参数： _mutex 初始化的互斥锁的指针
 _mutexattr 指向对象的指针，若为空则默认属性
 
3、申请互斥锁
 如果一个线程要占用共享资源，必须先申请对应互斥锁，使用函数：
 以阻塞方式申请互斥锁：
 
extern int pthread_mutex_lock(pthread_mutex* _mutex)
 
以非阻塞方式申请互斥锁：
 
extern int pthread_mutex_trylock(pthread_mutex* _mutex
 
4、释放互斥锁
 释放互斥锁函数：
 
extern int pthread_mutex_unlock(pthread_mutex_t* _mutex)
 
死锁
 
 
 
死锁是指一个资源被多次调用，而多次调用方都未能释放该资源就会造成一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁
 
 
死锁产生：
 一个线程内部多次加锁缺没有释放引起死锁
 多个线程内部多次调用引起死锁
 python中的实例

初始化互斥锁
 
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
 
 
 
上锁
 
int pthread_mutex_lock(pthread_mutex_t *mutex);
 
 
 
解锁
 
int pthread_mutex_unlock(pthread_mutex_t * mutex);
 
 
 
销毁互斥锁
 
int pthread_mutex_destroy(pthread_mutex_t *mutex);
 
 
 
#include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <unistd.h>
  
 pthread_mutex_t mutex;
 // print
 void printer(char *str)
 {
     pthread_mutex_lock(&mutex);
     while(*str!='\0')
     {
         putchar(*str);    
         fflush(stdout);
         str++;
         sleep(1);
     }
     printf("\n"); 
     pthread_mutex_unlock(&mutex);
 }
  
 // thread one
 void *thread_fun_1(void *arg)
 {
     char *str = "hello";
     printer(str); 
 }
  
 // thread two
 void *thread_fun_2(void *arg)
 {
     char *str = "world";
     printer(str); 
 }
  
 int main(void)
 {
     pthread_t tid1, tid2;
     int err1, err2;
         pthread_mutex_init(&mutex, NULL);
     // creat two thread
     err1 = pthread_create(&tid1, NULL, thread_fun_1, NULL);
     err2 = pthread_create(&tid2, NULL, thread_fun_2, NULL);
     // wait thread end
     pthread_join(tid1, NULL);
     pthread_join(tid2, NULL); 
     pthread_mutex_destroy(&mutex);
     return 0;
 }