linux 多线程编程-（3）互斥锁

互斥锁

互斥量（mutex）是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。
如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个（需要竞争）变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。

在设计时需要规定所有的线程必须遵守相同的数据访问规则。只有这样，互斥机制才能正常工作。操作系统并不会做数据访问的串行化。如果允许其中的某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其它的线程在使用共享资源前都获取了锁，也还是会出现数据不一致的问题。

互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy。
　　
【互斥锁的操作流程如下】：

1. 在访问共享资源后临界区域前，对互斥量进行加锁；

2. 在访问完成后释放互斥锁导上的锁；

3. 对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。

常用API

头文件

#include <pthread.h>

1、创建互斥锁

函数原型

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

函数参数
mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量
attr：互斥量的属性，一般设为NULL，要用默认的属性初始化互斥量，只需把attr设置为NULL。

除非需要创建一个非默认属性的条件变量，否则pthread_cont_init函数的attr参数可以设置为NULL。

返回值
返回：若成功返回0，否则返回错误编号，

2、销毁互斥锁

函数原型

int pthread_mutex_destroy(pthread_mutex_t *mutex);

函数参数
mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量

返回值
返回：若成功返回0，否则返回错误编号

3、加锁（两种）

第一种加锁：
函数原型

int pthread_mutex_lock(pthread_mutex_t *mutex);

第二种加锁：

如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。
如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。

函数原型

int pthread_mutex_trylock(pthread_mutex_t *mutex);

函数参数
mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量

返回值
返回：若成功返回0，否则返回错误编号

4、解锁

函数原型

int pthread_mutex_unlock(pthread_mutex_t *mutex);

函数参数
mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量

返回值
返回：若成功返回0，否则返回错误编号

注意一定要在改变条件状态以后再给线程发信号。

死锁

是指两个或两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。
比如：创建了两个锁，线程A拿了第一个锁，线程B拿了第二个锁，但是中途线程A又要继续拿第二个锁，由于线程B中的第二个锁还没有被释放，就会出现僵持的现象。

示例

上图中的代码 假设func1先运行他拿走mutex之后睡眠一秒，这时候func2会拿到mutex2，
func1睡眠一秒之后func1想拿mutex2的时候，mutex2已经被func2拿走了，而func2睡眠
一秒后也和func1一样拿不到mutex，就会一直僵持着。

互斥锁简单示例

#include<stdio.h>
#include<pthread.h>
int data =0;
pthread_mutex_t  mutex;//定义互斥量（锁）
void *func1(void*arg )
{
        pthread_mutex_lock(&mutex);//上锁
        int i;
        for(i=0;i<5;i++){
                printf("t1:%d\n",data++);
                sleep(1);
        }
        pthread_mutex_unlock(&mutex);//解锁
}
void *func2(void*arg )
{
        pthread_mutex_lock(&mutex);//上锁
        int i;
        for(i=0;i<5;i++){
                printf("t2:%d\n",data++);
                sleep(1);
        }
        pthread_mutex_unlock(&mutex);//解锁
}
void *func3(void*arg )
{
        pthread_mutex_lock(&mutex);//上锁
        int i;
        for(i=0;i<5;i++){
                printf("t3:%d\n",data++);
                sleep(1);
        }
        pthread_mutex_unlock(&mutex);//解锁
}
int main()
{
        pthread_t t1;
        pthread_t t2;
        pthread_t t3;
        pthread_mutex_init(&mutex,NULL);//创建锁
        pthread_create(&t1,NULL,func1,NULL);
        pthread_create(&t2,NULL,func2,NULL);
        pthread_create(&t3,NULL,func3,NULL);
        pthread_join(t1,NULL);
        pthread_join(t2,NULL);
        pthread_join(t3,NULL);
        pthread_mutex_destroy(&mutex);//关闭锁
        return 0;
}

三个线程争夺，谁先拿到锁，谁就先执行锁后面的代码，直到释放锁后，剩下的两个线程继续争夺，没争夺到的就先堵塞，堵塞到有锁拿的时候才执行。这样就保证了被锁的线程不会被打断。

结果