Linux多线程之线程互斥

(｡･∀･)ﾉﾞ嗨！你好这里是ky233的主页：这里是ky233的主页，欢迎光临~https://blog.csdn.net/ky233?type=blog

点个关注不迷路⌯'▾'⌯

一、互斥

1.线程间的互斥相关背景概念

2.互斥锁

三、可重入和线程安全

1.概念

2.常见的线程安全和不安全的问题

3.常见的可重入与不可重入情况

4.可重入与线程安全的联系

5.可重入与线程安全的区别

四、死锁

1.死锁的四个必要条件

2.避免死锁的方法

一、互斥

1.线程间的互斥相关背景概念

临界资源：多线程执行流共享的情况下，同一时间只能由一个执行流访问的资源就叫做临界资源
临界区：每个线程内部，访问临界自娱的代码，就叫做临界区
互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

接下来验证一个问题，如果多线程访问同一个全局变量，并对它进行数据计算，多线程会互相影响吗？

一个看似没问题的多线程抢票程序

void* getTickets(void* args)
{
    (void)args;
    while(1)
    {
        if(tickets>0)
        {
            usleep(1000);
            printf("%p:%d\n",pthread_self(),tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_t t1,t2,t3;
    pthread_create(&t1,nullptr,getTickets,nullptr);
    pthread_create(&t2,nullptr,getTickets,nullptr);
    pthread_create(&t3,nullptr,getTickets,nullptr);
    pthread_join(t1,nullptr);
    pthread_join(t2,nullptr);
    pthread_join(t3,nullptr);
}

抢票到最后，不仅仅出现了有两个11张票的情况，甚至还出现了剩余-1张票的情况！所以如果我们不加以保护的话就会引起这种现象

我们用的方式是--，我们都知道--分为三个动作，先在对应的线程把数据读取到CPU中，然后--，最后返回内存，可是如果在还没--的时候cpu进行调度切换了呢？就会导致这个线程认为还有999张票，下一个也是认为999张票，可是下一个线程做完操作了把998返回去了，然后这时候刚刚的线程进来了，那么这个时候就会把之前保存在线程上下文数据中的999返回到CPU中，然后继续没做完的操作并返回998，那么这个时候已经卖出去两张票了，可是剩余的却是998张票！

这样就导致了我们在并发访问的时候，导致了我们数据不一致的问题！

那么要怎么避免这样的问题产生呢！

2.互斥锁

1.用法

pthread_mutex_t mtx;//首先要先定义一把锁
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
//之后对锁进行初始化操作

参数一：开始定义的锁
参数二：初始化时互斥锁的相关属性设置，传递nullptr使用默认的属性
返回值：成功为0，失败返回错误码
如果是全局或者静态的也可以使用这个宏来初始化：PTHREAD_MUTEX_INITIAILZER

那么如何进行加锁保护呢？

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数一：传入刚刚创建的锁
我们在需要串行化的时候加锁就好了

在我们每个线程进入临界区的时候，就会带上一把锁，这个锁在同一时刻只有一个线程可以拿到，其他没有所得线程只能在这里阻塞等待，直到拿到锁的线程解锁之后，并且拿到锁之后才能进入临界区！这就叫做互斥特点

解锁：

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数一：传入刚刚创建的锁

代码演示：

#include <iostream>
#include <pthread.h>
#include <stdio.h>
#include <errno.h>
#include <thread>
#include <string.h>
#include <unistd.h>

using namespace std;
// 创建锁
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
//临界资源
int tickets = 10000;

void *getTickets(void *args)
{
    (void)args;
    while (1)
    {
        // 加锁
        pthread_mutex_lock(&mtx);
        //临界区
        if (tickets > 0)
        {
            usleep(1000);
            tickets--;
            // 解锁
            pthread_mutex_unlock(&mtx);
            printf("%s:%d\n", (char*)args, tickets);
        }
        else
        {
            // 解锁
            pthread_mutex_unlock(&mtx);
            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_t t1, t2, t3;
    pthread_create(&t1, nullptr, getTickets, (void*)"线程1");
    pthread_create(&t2, nullptr, getTickets, (void*)"线程2");
    pthread_create(&t3, nullptr, getTickets, (void*)"线程3");
    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);
}

加锁的时候一定要保证我们加锁的粒度越小越好！如果是局部的锁，要记得在最后释放

pthread_mutex_destroy(&mtx);

2.加锁之后，线程在临界区是否会被切换呢？会有问题吗？原子性的体现在哪里

答案是会被切换的！但是不会出现上述问题了！虽然我们还是会被切换，但是我们一已经拿到唯一的一把锁了，而且我们又没有释放锁，所以其他线程不能访问临界区！所以也就不能来进入临界区修改资源

原子性体现：在其他线程看来，只有两种情况是有意义的，一种是：没有线程持有锁，这代表的是什么都没做，谁都可以申请锁！第二种：持有锁的线程释放锁了，这也代表的是谁都可以申请锁！所以只有这两种情况队以其他线程来说是有意义的！所以在其他线程来看，当持有锁的线程在进行对应的任务时，这就是原子的！

3.那么加锁就是串行执行了吗？

经过了上面的了解，那么我们对于这个问题也就迎刃而解了，是的，在访问临界区的时候一i当时串行执行的

4.锁本身是否是临界资源呢？

要访问临界资源，每一个线程都必须先看到同一把锁并访问，那么锁本身是否是临界资源呢？那么谁来保证锁的安全呢？

所以为了保证锁的安全，申请和释放锁必须是原子的！！

5.锁是如何实现的

首先先来补充一个背景知识：在执行流视角我们的寄存器的空间是被共享的，但是此村其里面的内容，是被每一个执行流私有的，属于执行流的上下文，切换的时候每个执行流都会带走属于自己的执行流！

第一步：在最开始的时候我们的锁就是个整数比如说是1，其中当我们的指令在执行第一条汇编的时候，把0放到%al寄存器里，这个0是属于我们线程的上下文的

第二步：我们交换把寄存器的值和锁的值相交换，所以寄存器里面的值就变为1，mtx里面的值变为0

第三步：线程来判断寄存器的内容是否是大于0的，如果大于0则返回，代表申请锁成功！如果不大于0，则被挂起等待

在这过程中，是随时都有可能被切换的，如果被切换了，线程1就带着%al中的数据一起被切换了，线程2则要从新开始置0、交换，这个时候mtx里面的数据是0，寄存器里面的数据也是0，交换后还是0，则不满足第三步获取锁的条件，则线程2被阻塞挂起，其他线程也是一样的，直到CPU再次调度回线程1，然后线程1，带着上次带走的数据继续放回寄存器里，然后继续未完成的步骤，直到申请所成功！

也就是说当1被线程1所拿到之后，就相当于这把锁已经被线程1拿到了，而这三部每一步都是原子的，执行每一步的过程中都是不可以被调度的！这样也就相当于获取锁是原子的了！

三、可重入和线程安全

1.概念

线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。
重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数。