Linux多线程同步与互斥：从互斥锁原理到死锁防范的深度实践

线程的同步互斥

这里我们不仅会介绍线程的同步互斥，也会介绍进程的同步互斥，比如信号量就可以实现线程或者进程间的同步互斥

知识点1【同步互斥的概念】

互斥：同一时间，只能执行一个任务（进程或者线程），谁先执行不确定

同步：同一时间，只能执行一个任务（进程或者线程），有顺序的执行

知识点2【互斥锁】

用于线程之间的互斥，不能用于同步

互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁有两种状态：加锁和解锁。

这里我们使用C语言模拟一下这个过程

线程函数函数体：

while(1)//抢锁
{ if(flag == 0){  flag = 1;//加锁线程操作;flag = 0;//解锁}
}

其中flag 是一个进程中的全局变量。

下面我们详细介绍一下互斥锁的操作流程

互斥锁的操作流程

1、访问共享资源（执行线程操作）前，对互斥锁进行加锁

2、访问完成后解锁

注意：对互斥锁加锁后，任何其他试图再次对互斥锁再次加锁的线程都会被阻塞，知道锁被释放

互斥锁的类型：pthread_mutex_t

知识点3【互斥锁的API】

1、初始化锁 pthread_mutex_init()

函数介绍
```
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
```
功能：

初始化一个互斥锁

参数：

mutex：互斥锁地址，因为初始化函数会对锁的内容进行修改，因此需要地址

attr：互斥量的属性，我们一般使用默认属性 NULL

返回值：

成功：0，成功申请的锁默认是打开的

失败：非0错误码

这里我们也可以使用另一种使用默认属性初始化互斥锁方式：在定义锁的时候使用宏
```
phthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
```
这里大家注意，由于这种方式是宏，因此无法进行错误检测（宏替换在预处理阶段完成，不进行错误检测），因此我们一般不用这种方法

2、销毁互斥锁 pthread_mutex_destroy()

函数介绍
```
#include <phread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
```
功能：

销毁指定的一个互斥锁。互斥锁使用完后，必须对互斥锁进行销毁，以释放资源

参数：

mutex：指定的互斥锁地址

返回值：

成功：0

失败：非0错误码

3、申请上锁 pthread_mutex_lock()

函数介绍
```
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
```
功能：

对互斥锁上锁，如果互斥锁已经上锁，则调用者阻塞，直到互斥锁解锁后才能上锁

参数：

mutex：互斥锁地址

返回值：

成功：0

失败：非0 错误码

这里补充一个函数
```
int pthread_mutex_trylock(pthread_mutex_t *mutex);
```
尝试上锁，这个是不阻塞的，因此需要配合循环和条件判断使用

如果互斥锁没有上锁，则上锁，返回0；

如果互斥锁已上锁，则函数直接返回失败，即EBUSY。

4、解锁 pthread_mutex_unlock()

函数介绍
```
#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);
```
功能：

对指定的互斥锁解锁。

参数：

mutex：互斥锁地址

返回值：

成功：0

失败：非0错误码

案例1 没有互斥锁的代码运行情况

我们这里封装一个函数void my_printf(char *arr)，用来打印字符串，但是是每秒打印一个字符

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
//my_printf函数声明
void my_printf(char *arr);//线程1函数声明
void *my_fun01(void *arg);//线程2函数声明
void *my_fun02(void *arg);//这里的线程1，2函数功能是一样的，大家可以使用同一个函数，不会有影响，我这样写只是为了让代码功能更加直观int main(int argc, char const *argv[])
{//创建两个线程pthread_t tid1,tid2;pthread_create(&tid1,NULL,my_fun01,"hello");pthread_create(&tid2,NULL,my_fun02,"world");//释放线程pthread_join(tid1,NULL);pthread_join(tid2,NULL);return 0;
}
//my_printf函数实现
void my_printf(char *arr)
{while(*arr != '\\0'){printf("%c",*arr);fflush(stdout);//这个是必须的，因为上面没有行刷新，因此我们需要强制刷新刷新缓冲区//这里复习一下缓冲区的刷新方式 行刷新 慢刷新 结束刷新 强制刷新arr++;sleep(1);}
}
//线程1函数实现
void *my_fun01(void *arg)
{char *arr = (char *)arg;my_printf(arr);return NULL;
}
//线程2函数实现
void *my_fun02(void *arg)
{char *arr = (char *)arg;my_printf(arr);return NULL;
}

代码运行结果

可以看到代码的输出很随机

请仔细看注释，注释中补充了缓冲区的刷新方式，只是简述，大家忘记的自行利用AI查询即可

案例2 使用互斥锁的代码运行情况

代码演示

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
//互斥锁的定义
pthread_mutex_t mutex;//my_printf函数声明
void my_printf(char *arr);//线程1函数声明
void *my_fun01(void *arg);//线程2函数声明
void *my_fun02(void *arg);//这里的线程1，2函数功能是一样的，大家可以使用同一个函数，不会有影响，我这样写只是为了让代码功能更加直观int main(int argc, char const *argv[])
{//创建两个线程pthread_t tid1,tid2;//锁的初始化（默认是开锁状态）pthread_mutex_init(&mutex,NULL);pthread_create(&tid1,NULL,my_fun01,"hello");pthread_create(&tid2,NULL,my_fun02,"world");//释放线程pthread_join(tid1,NULL);pthread_join(tid2,NULL);//互斥锁已经使用完毕，销毁锁pthread_mutex_destroy(&mutex);return 0;
}
//my_printf函数实现
void my_printf(char *arr)
{while(*arr != '\\0'){printf("%c",*arr);fflush(stdout);//这个是必须的，因为上面没有行刷新，因此我们需要强制刷新刷新缓冲区//这里复习一下缓冲区的刷新方式 行刷新 慢刷新 结束刷新 强制刷新arr++;sleep(1);}
}
//线程1函数实现
void *my_fun01(void *arg)
{//加锁pthread_mutex_lock(&mutex);//线程1操作代码char *arr = (char *)arg;my_printf(arg);//解锁pthread_mutex_unlock(&mutex);return NULL;
}
//线程2函数实现
void *my_fun02(void *arg)
{//加锁pthread_mutex_lock(&mutex);//线程1操作代码char *arr = (char *)arg;my_printf(arg);//解锁pthread_mutex_unlock(&mutex);return NULL;
}

代码运行结果