【多线程】线程互斥 {多执行流并发执行的数据竞争问题，互斥锁的基本用法，pthread_mutex系列函数，互斥锁的原理；死锁；可重入函数和线程安全}

一、进程线程间通信的相关概念

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

二、互斥锁

2.1 多执行流并发执行的数据竞争问题

大部分情况，线程使用的数据都是局部变量，变量存储在线程栈空间内。这种情况，变量归属单个线程，其他线程无法访问这种变量。
但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。比如，全局数据、堆空间数据。
多个线程并发的操作共享变量，会带来数据竞争，冲突以及数据不一致等问题。

测试程序：

int tickets = 100; //共有100张票

void *ThreadRoutine(void *name)
{
    while (1)
    {
        if (tickets > 0)
        {
            usleep(rand() % 1000); // 模拟业务过程花费的时间
            printf("%s sells ticket:%d\n", (char *)name, tickets);
            --tickets;
        }
        else
        {
            break;
        }
        usleep(rand() % 1000); // 模拟处理其他业务花费的时间
    }
    return nullptr;
}

int main()
{
    srand((unsigned)time(nullptr));
    pthread_t tid1, tid2, tid3, tid4;
    pthread_create(&tid1, nullptr, ThreadRoutine, (void *)"child thread 1");
    pthread_create(&tid2, nullptr, ThreadRoutine, (void *)"child thread 2");
    pthread_create(&tid3, nullptr, ThreadRoutine, (void *)"child thread 3");
    pthread_create(&tid4, nullptr, ThreadRoutine, (void *)"child thread 4");

    pthread_join(tid1, nullptr);
    pthread_join(tid2, nullptr);
    pthread_join(tid3, nullptr);
    pthread_join(tid4, nullptr);
    return 0;
}

运行结果：

在这里插入图片描述

同一编号的票被多个线程售出
某些线程售出了负数编号的票

该程序存在数据竞争的问题，即公共变量tickets被多执行流同时访问和修改。

提示：除了多线程进程外，信号处理函数也是异步执行的（多执行流执行），同样存在数据竞争的问题。

并发运行问题

例如：tickets > 0和--tickets操作并不是原子性操作，而是对应三条汇编指令：

将数据从内存加载到寄存器（当前线程的上下文中）
进行逻辑运算或算数运算
将数据写回内存

在这三条步骤的其中任何一步，该线程都有可能被切换，切换前线程上下文会被保存。其他线程在执行时也对tickets进行了访问和修改。当原线程再次被CPU调度执行时，恢复上下文数据，此时的寄存器与内存就会发生数据不一致的错误。

并行运行问题

多核CPU允许多线程并行（同时）运行。在ThreadRoutine函数中，由于没有对访问tickets的操作进行互斥，可能会导致多个线程同时读取和修改tickets变量，从而产生不可预测的结果。

例如：当多个线程同时执行if (tickets > 0)语句时，可能会出现以下情况：

线程A和线程B同时读取tickets的值为1。
线程A先执行--tickets操作，将tickets的值减为0。
线程B再执行--tickets操作，将tickets的值减为-1。

这样，就会出现某些线程售出了负数编号的票。

2.2 互斥锁的基本用法

为了解决数据竞争问题，可以使用互斥锁（Mutex）来保护对tickets变量的访问。互斥锁可以确保在同一时间只有一个线程能够访问临界区（对tickets变量的访问），从而避免数据竞争的发生。

在这里插入图片描述

下面是互斥锁的基本使用方法：

定义互斥锁变量：在使用互斥锁之前，需要先定义一个互斥锁变量。可以使用pthread_mutex_t类型来声明互斥锁变量，例如：pthread_mutex_t mutex;
初始化互斥锁：在使用互斥锁之前，需要对互斥锁进行初始化。
- 静态初始化：在定义互斥锁变量时，使用PTHREAD_MUTEX_INITIALIZER宏进行初始化。
- 动态初始化：可以使用pthread_mutex_init函数来初始化互斥锁，例如：pthread_mutex_init(&mutex, NULL);。第一个参数是要初始化的互斥锁变量，第二个参数是互斥锁的属性，通常使用NULL表示使用默认属性；
加锁：在访问共享资源之前，需要先加锁。可以使用pthread_mutex_lock函数来加锁，例如：pthread_mutex_lock(&mutex);。如果互斥锁已经被其他线程锁定，那么当前线程会被阻塞，直到互斥锁被解锁。
访问共享资源：在互斥锁被锁定的情况下，可以安全地串行访问共享资源。
解锁：在访问共享资源完成后，需要解锁互斥锁，以便其他线程可以继续访问共享资源。可以使用pthread_mutex_unlock函数来解锁，例如：pthread_mutex_unlock(&mutex);。
销毁互斥锁：
- 不再需要使用互斥锁时，需要将其销毁。可以使用pthread_mutex_destroy函数来销毁互斥锁，例如：pthread_mutex_destroy(&mutex);。
- 静态初始化的互斥锁在程序结束时会自动被系统回收，无需手动销毁。
- 不要销毁一个已经加锁的互斥量
- 对于已经销毁的互斥量，要确保后面不会有线程再尝试加锁

我们将上面的售票程序加入互斥锁：

int tickets = 100; //临界资源
// 定义一个全局的互斥锁变量，并利用宏进行初始化（静态初始化）
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

void *ThreadRoutine(void *name)
{
    while (1)
    {
        // 在访问共享资源之前，需要先加锁。
        pthread_mutex_lock(&mtx);
        //临界区
        if (tickets > 0)
        {
            usleep(rand() % 1000); // 模拟业务过程花费的时间
            printf("%s sells ticket:%d\n", (char *)name, tickets);
            --tickets;
            // 在访问共享资源完成后，需要解锁互斥锁。
            pthread_mutex_unlock(&mtx);
        }
        else
        {
            // 在访问共享资源完成后，需要解锁互斥锁。
            pthread_mutex_unlock(&mtx);
            break;
        }
        // 在此处解锁？不行，如果线程执行break，就不会解锁互斥锁。其他线程会被一直阻塞。
        usleep(rand() % 1000); // 模拟处理其他业务花费的时间
    }
    return nullptr;
}

运行结果：

在这里插入图片描述

需要注意的几点：

在访问共享资源完成后，需要解锁互斥锁。否则，其他线程会被一直阻塞。需要特别注意break, goto等跳转语句跳过解锁函数。
被互斥锁锁定的临界区只能串行执行（互斥访问），虽然保证了多执行流访问临界资源的安全性，但是会在一定程度上降低程序的效率。
尽量保证被互斥锁锁定的代码都是访问临界资源的代码，不要将其他无关的操作也放入临界区中。因为相比并发或并行执行，临界区串行执行的效率较低。

再次改进上面的代码：

#define THREAD_NUM 5
int tickets = 100;

//声明一个ThreadData类，使线程入口函数的参数更多样化。
class ThreadData
{
public:
    string _tname; //线程名
    pthread_mutex_t *_pmtx; //互斥锁变量的地址

    ThreadData(const string &tname, pthread_mutex_t *pmtx)
        : _tname(tname),
          _pmtx(pmtx){};
};

void *ThreadRoutine(void *arg)
{
    ThreadData *td = (ThreadData *)arg;
    while (1)
    {
        // 在访问临界资源前进行加锁
        pthread_mutex_lock(td->_pmtx);
        if (tickets > 0)
        {
            usleep(rand() % 1000); // 模拟业务过程花费的时间
            printf("%s sells ticket:%d\n", td->_tname.c_str(), tickets);
            --tickets;
            // 不再访问临界资源时需要解锁。
            pthread_mutex_unlock(td->_pmtx);
        }
        else
        {
            // 不再访问临界资源时需要解锁。
            pthread_mutex_unlock(td->_pmtx);
            break;
        }
        usleep(rand() % 1000); // 模拟处理其他业务花费的时间
    }
    delete td; // 释放各自的ThreadData结构空间
    return nullptr;
}

int main()
{
    srand((unsigned)time(nullptr));
    // 在主线程栈区创建互斥锁变量
    pthread_mutex_t mtx;
    // 调用pthread_mutex_init初始化互斥锁（动态初始化）
    pthread_mutex_init(&mtx, nullptr);
    // 循环创建子线程
    pthread_t tid[THREAD_NUM];
    for (int i = 0; i < THREAD_NUM; ++i)
    {
        string tmp = "child thread ";
        tmp += to_string(i + 1);
        ThreadData *td = new ThreadData(tmp, &mtx);
        pthread_create(tid + i, nullptr, ThreadRoutine, td); //传入ThreadData对象的指针
    }
    // 循环等待子线程
    for (int i = 0; i < THREAD_NUM; ++i)
    {
        pthread_join(tid[i], nullptr);
    }
    // 在不再需要使用互斥锁时，需要将其销毁。（动态初始化的互斥锁需要进行销毁，而静态初始化不需要）
    pthread_mutex_destroy(&mtx);
    return 0;
}

新的问题：

加锁了之后，线程在执行临界区代码时，是否会被切换，会有问题吗?
会被切换，但不会有问题！虽然被切换了，但是你是持有锁被切换的, 所以其他抢票线程要执行临界区代码，也必须先申请锁，而它是无法申请成功的。所以，也不会让其他线程进入临界区，就保证了临界区中数据一致性！
对于访问临界资源的线程而言，临界区代码要么全部执行成功，要么全部不执行，访问临界资源的操作不可被中断（不能同时执行其他线程的临界区代码），这就是原子性的体现。
要访问临界资源，每一个线程都必须先申请锁，而锁本身就是一种共享资源，那么谁来保证锁的安全呢？

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

2.3 互斥锁的原理

在汇编层面，一条汇编语句要么已经执行完，要么就还没有执行，是原子性的。
为了实现互斥锁操作，大多数体系结构都提供了swap或exchange汇编指令，该指令的作用是把寄存器和内存单元的数据相交换，由于只有一条指令，保证了原子性。即使是多处理器平台（并行），访问内存的总线周期也有先后，一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。
CPU的寄存器数据，本质就是当前执行流的上下文。寄存器的存储空间被所有执行流共享，但是寄存器的内容是被每一个执行流私有的。所以在切换线程时，要将当前线程的寄存器数据保存到其PCB中，并恢复下一个线程的寄存器数据。

以下是加锁的核心汇编伪代码：

lock:
	movb $0, %al // 将数值0，move到al寄存器中
    xchgb %al, mutex //交换al寄存器与mutex变量（内存）的数据
    if(al寄存器的内容 > 0)
    {
        return 0;
    }
	else
        挂起等待;
	goto lock; //跳转到lock标签，再次申请锁

我们可以将互斥锁变量mutex理解成一个整形变量，值为1表示互斥锁未被线程持有；值为0，表示互斥锁已经被其他线程锁定。创建互斥锁变量并进行初始化后，其默认值为1。
由于exchange汇编指令是原子的，所以不管线程如何切换，只有一个线程能够将mutex（内存）中的1值交换到自己的寄存器当中，即该线程的上下文中。而线程上下文是线程的私有数据，实现了公有到私有的转换。同时寄存器当中的0值被交换到了mutex中，其他线程再进行交换也只能交换到0。
在进行if判断时，交换到1值的线程执行return 0，可以安全地进入临界区访问临界资源；而交换到0值的线程阻塞等待，直到互斥锁被解锁，这些线程才会被唤醒，然后再次尝试申请锁。

以下是解锁的核心汇编伪代码：

unlock:
	movb $1, mutex //将数值1，move到mutex变量（内存）
    唤醒等待mutex的线程;
	return 0;

当持有锁的线程访问完临界资源后，会将mutex变量重新置为1，即解锁互斥锁。
同时，应该唤醒等待互斥锁解锁的线程，让他们再次竞争申请锁。

回答之前的问题：

谁来保证锁的安全呢？

为了保证锁的安全，申请和释放锁，必须是原子的！在设计加锁时，通过一条原子性的exchange指令，保证了加锁和解锁的原子性。
加锁了之后，线程在临界区中，是否会切换，会有问题吗?

线程在临界区中也可能会被切换，但他是持有锁被切换的，所谓持有锁切换是指互斥锁的1值保存在当前线程的上下文，被当前线程私有。而其他线程即使被CPU调度执行，也无法抢占互斥锁，也就无法访问临界区代码。所以不会有任何问题。

三、可重入函数和线程安全

可重入函数：同一个函数被多个执行流同时进入，就叫重入。如果该函数在被重入执行的过程中不会出现任何错误，则被称为可重入函数。反之就是不可重入函数。
线程安全：多个线程并发执行时，在没有锁保护的情况下访问了共享资源（如全局或静态变量，堆区数据等），会出现数据竞争从而导致数据冲突，数据不一致等线程安全问题。

3.1 线程安全的情况

仅使用本地（局部）数据，或者通过制作全局数据的本地拷贝来保护全局数据。
使用互斥锁（Mutex）来保护对共享资源的访问。互斥锁可以确保在同一时间只有一个线程能够访问临界区，从而避免数据竞争的发生。
每个线程对共享资源只有读取的权限，而没有写入的权限，一般来说这些线程是安全的。
不调用线程不安全的函数

3.2 可重入函数的情况

仅使用本地（局部）数据，或者通过制作全局数据的本地拷贝来保护全局数据。
使用互斥锁（Mutex）来保护对共享资源的访问。如全局、静态变量或其他共享资源。
不调用不可重入函数

常见不可重入的情况

调用了malloc/free函数，因为Linux内核是用全局链表和全局红黑树结构来组织和管理堆空间的。（请看提示）
调用了标准I/O库函数，因为标准I/O库的很多实现都以不可重入的方式使用了全局数据结构。

提示：

关于Linux内核中的堆区管理，请阅读：【多线程】线程的概念 {Linux内核中的堆区管理；虚拟地址到物理地址的转换，页，页框，页表，MMU内存管理单元；Linux线程概念，轻量级进程；线程共享进程的资源；线程的优缺点；线程的用途}-CSDN博客
关于多执行流调用不可重入函数插入链表节点，请阅读：【信号】信号处理 {信号处理的时机；内核态和用户态；信号捕捉的原理；信号处理函数：signal, sigaction；可重入函数；volatile关键字；SIGCHLD信号}-CSDN博客