[ Linux ] 互斥量实现原理，线程安全

news2025/2/6 13:13:07

上篇文章我们对抢票系统做了加锁处理，对互斥量tickets进行加锁。而本篇博文来谈谈互斥量实现的原理以及相关问题。

1.上篇遗留问题

我们在临界资源对应的临界区中加锁了，就不是多行代码了吗？如果还是多行代码，难道不会被切换走吗？

2.如何实现线程加锁和解锁的原子性

3.可重入和线程安全

3.1概念

3.2常见的线程安全的情况

3.3常见的线程安全的情况

3.4常见不可重入的情况

3.5常见可重入的情况

3.6可重入与线程安全联系

3.7可重入与线程安全区别

1.上篇遗留问题

我们在临界资源对应的临界区中加锁了，就不是多行代码了吗？如果还是多行代码，难道不会被切换走吗？

在讨论这个问题之前我们先复习一下昨天的代码：

#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <pthread.h>

using namespace std;

int tickets = 1000;

//全局初始化
//pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_t mutex;//锁的声明

void *startRoutine(void *args)
{
    const char* name = static_cast<const char *>(args);

    while(true)
    {
        pthread_mutex_lock(&mutex);//如果申请不到就会阻塞线程
        if(tickets > 0)
        {
            usleep(1000);
            cout<<name<<" 抢到了一张票，票的编号是...."<< tickets << endl;
            tickets--;
            pthread_mutex_unlock(&mutex);
        }
        else
        {
            cout<<name<<" 没有抢到票,没有票了............"<< tickets << endl;
            pthread_mutex_unlock(&mutex);
            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_mutex_init(&mutex,nullptr);
    pthread_t tid1,tid2,tid3,tid4;

    pthread_create(&tid1,nullptr,startRoutine,(void*)"thread 1");
    pthread_create(&tid2,nullptr,startRoutine,(void*)"thread 2");
    pthread_create(&tid3,nullptr,startRoutine,(void*)"thread 3");
    pthread_create(&tid4,nullptr,startRoutine,(void*)"thread 4");



    pthread_join(tid1,nullptr);
    pthread_join(tid2,nullptr);
    pthread_join(tid3,nullptr);
    pthread_join(tid4,nullptr);

    pthread_mutex_destroy(&mutex);



    return 0;
}

我们发现这是我们的加锁后抢票的代码，我们也可以在主线程内定义锁，然后通过结构体传入新线程内，具体的玩法如下代码所示：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <cstdlib>
#include <pthread.h>

using namespace std;

int tickets = 10000;

//全局初始化
//pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// pthread_mutex_t mutex;//锁的声明
#define NAMESIZE 64
typedef struct threadData
{
    char name[NAMESIZE];
    pthread_mutex_t *mutexp;//声明锁
}threadData;

void *startRoutine(void *args)
{
    //const char* name = static_cast<const char *>(args);
    threadData *td = static_cast<threadData*>(args);
    while(true)
    {
        pthread_mutex_lock(td->mutexp);//如果申请不到就会阻塞线程
        if(tickets > 0)
        {
            usleep(1000);
            cout<<td->name<<" 抢到了一张票，票的编号是...."<< tickets << endl;
            tickets--;
            pthread_mutex_unlock(td->mutexp);
            usleep(200);
        }
        else
        {
            cout<<td->name<<" 没有抢到票,没有票了............"<< tickets << endl;
            pthread_mutex_unlock(td->mutexp);
            break;
        }
    }
    return nullptr;
}

int main()
{
    //pthread_mutex_init(&mutex,nullptr);
    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_t tid1,tid2,tid3,tid4;

    threadData *td1 = new threadData();
    strcpy(td1->name,"thread 1");
    td1->mutexp = &mutex;
    pthread_create(&tid1,nullptr,startRoutine,td1);

    threadData *td2 = new threadData();
    strcpy(td2->name,"thread 2");
    td2->mutexp = &mutex;
    pthread_create(&tid2,nullptr,startRoutine,td2);

    threadData *td3 = new threadData();
    strcpy(td3->name,"thread 3");
    td3->mutexp = &mutex;
    pthread_create(&tid3,nullptr,startRoutine,td3);

    threadData *td4 = new threadData();
    strcpy(td4->name,"thread 4");
    td4->mutexp = &mutex;
    pthread_create(&tid4,nullptr,startRoutine,td4);



    pthread_join(tid1,nullptr);
    pthread_join(tid2,nullptr);
    pthread_join(tid3,nullptr);
    pthread_join(tid4,nullptr);

    //pthread_mutex_destroy(&mutex);



    return 0;
}

那么我们在临界资源对应的临界区中加锁了，就不是多行代码了吗？如果还是多行代码，难道不会被切换走吗？

我们在临界区内可以被切走吗？

答案是当然可以。因为线程执行的加锁解锁也是代码，线程在任意代码出都可以被切换，但是线程加锁是原子的，要么拿到锁要么拿不到锁。但是由于该线程占用着锁，即使在临界区内被切换走，其他线程也不可能访问临界区，因为他们根本拿不到锁，锁已经被刚才的线程占用了。因此该线程会被阻塞在申请锁的阶段。因此一个线程持有锁，该线程根本不担心任何的切换问题。对于其他线程而言，该线程访问临界区只有没有进入和使用完毕两种状态对其他线程有意义。

2.如何实现线程加锁和解锁的原子性

经过上面的理解，我们已经可以意识到单纯的++i和i++都不是原子的，有可能会有数据一致性问题。

为了实现互斥锁操作，大多数体系结构都提供了swap或者exchange指令，该指令的作用是把寄存器和内存单元的数据相交换，由于只有一条指令，保证了原子性，即使是多处理平台，访问内存的总线周期也有先有后，一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。

凡是在寄存器中的数据，全部都是线程的内部上下文！！多个线程看起来同时在访问寄存器，但是互不印象。

本质：将数据从内存读入寄存器，本质是将数据从共享变成线程私有！由于是交换而不是拷贝，因此这个变量只有一份，就犹如一个令牌，谁拿到这个令牌就相当于谁持有锁！而被该线程私有！

3.可重入和线程安全

3.1概念

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