Linux系统编程——线程（三）互斥量相关API 和线程死锁

互斥量（mutex） 从本质上就是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。

对互斥量进行加锁后，其他线程试图再次对互斥量加锁，则将会被阻塞，直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。

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

静态初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
动态初始化：pthread_mutex_init(&mutex,NULL);

所有API头文件

#include <pthread.h>

互斥锁包含创建、销毁、加锁、解锁等4种操作

创建和销毁

函数原型

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
//创建
int pthread_mutex_destroy(pthread_mutex_t *mutex);
//销毁
// 若成功返回0，否则返回错误编号

要用默认的属性初始化互斥量，则需把attr设置为NULL。

加锁和解锁

函数原型

int pthread_mutex_lock(pthread_mutex_t *mutex);//加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);//非阻塞加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁
// 返回：若成功返回0，否则返回错误编号

其中函数pthread_mutex_trylock是pthread_mutex_lock的非阻塞版本。如果mutex参数所指定的互斥锁已经被锁定的话，调用pthread_mutex_trylock函数不会阻塞当前线程，而是立即返回一个值来描述互斥锁的状况。

示例代码

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
int p_data = 0;
pthread_mutex_t mutex; //定义线程互斥锁
void *func1(void *arg) 
{
    //sleep(1); 这里是为了让其他线程竞争,如果有此条的话，最先运行的有可能不是线程一
    pthread_mutex_lock(&mutex);  //对线程一加锁
    while(1){
        printf("t1 p_data : %d\n",p_data++);
        if(p_data == 5){        //等于5的话就退出
        	pthread_mutex_unlock(&mutex);  //对线程一解锁
            printf("t1 quit=========================\n");
            pthread_exit(NULL);  //退出线程一
            //exit(0);           //如果用exit退出的话，整个进程都会退出
        }
    }
}
void *func2(void *arg)
{
    while(1){
        printf("t2 param is %d\n",*((int *)arg));
        pthread_mutex_lock(&mutex); //对线程二加锁
        p_data++;                   //值加1
        pthread_mutex_unlock(&mutex); //对线程二解锁
        sleep(1);                    //这里延时1s是为了让线程一来竞争，如果最先运行的不是线程一，
        							//则让线程一运行，为了让线程一运行，让线程一退出
    }
}
int main()
{
     int ret;
     int param = 100;
     pthread_t t1;  //线程一
     pthread_t t2;  //线程二
     pthread_mutex_init(&mutex,NULL);  //创建线程互斥锁
     ret = pthread_create(&t1,NULL,func1,(void *)&param); //线程一
     ret = pthread_create(&t2,NULL,func2,(void *)&param); //线程二
     while(1){
     	printf("main p_data : %d\n",p_data);
        	sleep(1);   //让其他线程来竞争
     }
     pthread_join(t1,NULL); //等待线程一退出
     pthread_join(t2,NULL); //等待线程二退出
     pthread_mutex_destroy(&mutex); //销毁线程互斥锁
     return 0;
}

运行结果

当线程一加锁后，其他线程会一直堵塞，要等线程一解锁后其他线程再相互竞争竞争才能执行。

当把 pthread_exit(NULL) 换成 exit（0）时，执行线程一时，当到了5，线程就会退出，同时进程也会退出。

如

线程死锁

死锁是指两个或两个以上的进程（线程） 在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。

多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

例如

#include <stdio.h>
#include <pthread.h>
//两个线程互斥锁
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
void *func1(void *arg)
{
        pthread_mutex_lock(&mutex1);
        sleep(1);
        pthread_mutex_lock(&mutex2);
        while(1){
                printf("t1 param : %d\n",*((int *)arg));
                sleep(1);
        }
        pthread_mutex_unlock(&mutex1);
        pthread_mutet_unlock(&mutex2);
}

void *func2(void *arg)
{
        pthread_mutex_lock(&mutex2);
        sleep(1);
        pthread_mutex_lock(&mutex1);
        while(1){
                printf("t2 param : %d\n",*((int *)arg));
                sleep(1);
        }
        pthread_mutex_unlock(&mutex1);
        pthread_mutet_unlock(&mutex2);
}

int main()
{ 
        int ret;
        int param = 100;
        pthread_t t1;
        pthread_t t2;
        pthread_mutex_init(&mutex1,NULL);
        pthread_mutex_init(&mutex2,NULL);
        ret = pthread_create(&t1,NULL,func1,(void *)&param);
        ret = pthread_create(&t2,NULL,func2,(void *)&param);
        pthread_join(t1,NULL); //等待退出
        pthread_join(t2,NULL);
        pthread_mutex_destroy(&mutex1);  //销毁互斥锁
        pthread_mutex_destroy(&mutex2);
        return 0;
}

程序会一直堵塞下去，造成线程卡死

第一步：线程一对锁一上锁，线程二对锁二上锁。

第二步：线程一对锁二上锁，线程二对锁一上锁，但是两个锁都已经被上锁，并且都没有解锁，所以此时程序卡死，造成死锁。