Linux线程互斥

聪明的骑士

已于 2023-09-05 17:30:25 修改

阅读量497

点赞数 2

分类专栏： Linux 文章标签：算法

于 2023-09-01 23:51:08 首次发布

本文链接：https://blog.csdn.net/qq_65285898/article/details/132632326

版权

Linux 专栏收录该内容

36 篇文章 7 订阅

订阅专栏

一、线程不安全

1.线程不安全现象

我们都有在12306上抢票的经历吧，毕竟一打开满眼的候补着实是血压高了。

那我们也编写一个简单的抢票程序，设置全局变量tickets=10表示一共有十张票。创建五个线程每一个线程代表一个抢票者。五个抢票者不断抢票，抢到票后tickets减一并显示当前余票。

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<stdio.h>
#include<vector>
using namespace std;

#define NUM 5

int tickets = 10;

class pthread_data
{
public:
    pthread_t tid;
    char buffer[64];
};

void* start_routine(void* args)
{
    pthread_data* p = (pthread_data*)args;
    string s;
    s += p->buffer;
    s += "Remaining tickets:";
    while(1)
    {
        if(tickets > 0)
        {
            sleep(1);
            --tickets;
            printf("%s%d\n", s.c_str(), tickets);
        }
        else
            break;
    }
    pthread_exit(nullptr);
}

int main()
{
    vector<pthread_data*> vpd;
    for(int i = 0; i<NUM; ++i)
    {
        pthread_data* pd = new pthread_data;
        snprintf(pd->buffer, sizeof(pd->buffer), "thread:%d buy ticket:",i+1);
        pthread_create(&(pd->tid), nullptr, start_routine, (void*)pd);
        vpd.push_back(pd);
    }

    for(auto& e : vpd)
    {
        pthread_join(e->tid, nullptr);
        delete e;
    }

    return 0;
}

运行结果：

按道理说票减到0线程就都应该退出了，不应该出现余票为负的情况。

2.线程不安全程序的特质

线程不安全的程序一般都有这个特质：多个线程交叉执行，换句话说就是调度器频繁发生线程调度与切换。

虽然我们看上去所有线程都在同时执行，其实线程也是同时只能执行一个（单核），只是因为CPU运行速度太快，人是观察不到的。

对于线程切换有以下细节：

线程达到时间片，更高优先级线程需要执行，线程等待时会发生线程切换。
线程切换的检测是以内核态身份进行的，访问的是地址空间的内核部分，本质是操作系统在检测。
线程在从内核态转为用户态时，会检测是否达到线程切换条件。

CPU负责调度这些执行流，在一个线程达到被切换的条件时，CPU就会与该线程分离并执行另一个线程，当再次轮到这个被切走的线程后才会继续执行。

如果CPU不停切换线程，一个线程执行一半就接着执行下一个去了，这样的交叉执行就会导致线程不安全的问题。

3.线程不安全程序的原因

首先，语句的执行都需要先把变量从内存读取到寄存器，然后在寄存器内进行处理，最后再覆盖到内存中。根据这样的思想我们就可以试着解释上面的票数为什么会出现负数。

我们假设ticket=1依旧有五个线程抢票。

第一阶段

首先，内存中储存的ticket为1。第一个线程thread1开始执行，判断ticket>0。CPU从内存中将tickets的数值1读取到ebx寄存器内，tickets确实大于0，将1写回内存，执行内部语句。

当线程要执行sleep时，线程1会被切走。由于CPU和寄存器从只有一套，所以它的上下文数据会被保存起来。

接着，第二个线程thread2同样从内存中读取到tickets为1，判断为真，再次被切走。

当然还有thread3、thread4、thread5都会经历这样的过程。

第二阶段

我们首先要知道，--tickets需要三步才能完成，包括读取数据到寄存器，寄存器数据减一，将寄存器数据写回内存。

此时每一个线程都进入了if语句框，线程thread1再次被CPU执行。此时内存中的tickets为1，寄存器ebx读取数据变为1。此时执行--tickets，寄存器内数据变为0，最后将0写回到内存的tickets中。

thread2线程也被再次唤醒，再次读取tickets为0，减一得到-1，再将-1写回内存中。

后面的thread3、thread4、thread5也是这样的流程，最后内存中的tickets经过五次减一变成了-4，这就出现了负数。

二、线程互斥

1.基本概念

临界资源：多个执行流进行安全访问的共享资源。

上面的tickets就不是临界资源，因为多线程对它的访问出现了问题。

临界区：多个执行流中，访问临界资源的代码。

上面只有部分代码属于一部分临界区，对tickets进行if判断，打印，减一的那部分代码属于临界区。

互斥：让多个线程串行访问共享资源，任何时候只有一个执行流在访问共享资源。

上面的代码如果将多进程交叉并行变为串行，就不会出现进程不安全的情况。让共享资源变成临界资源其实就是实现互斥。

原子性：对一个资源进行访问的时候，要么不做，要么就做完。

在前面也说过像加加（++）和减减（--）这样的操作，看似只有一条代码，但是它对应的汇编指令有3条，也就是说这个操作不能一次完成。

现在的我们可以认为：对资源进行操作，如果只用一条汇编就能完成，那么就说该操作具有原子性。（这只是原子性表述的其中一种）

2.锁

（1）认识锁

要想解决多线程的数据不一致问题需要做到以下几点：

代码必须有互斥行为，当一个线程进入临界区执行代码时，不允许其他线程进入该临界区。
如果有多个线程同时请求执行临界区代码，并且临界区没有线程在执行代码，那么只允许一个线程进入该临界区。
如果线程不在临界区中执行代码，那么该线程也不能阻止其他线程进入临界区。

其实做到上面三点只需要一把互斥锁，你可以将锁看作一个通行证，持有锁的线程才能进入临界区中执行代码，其他线程不持有锁，无法进入该临界区。

加锁本质就是让共享资源临界资源化，多个线程串行访问共享资源，从而保护共享资源的安全。

互斥锁本质上就是一个类（class pthread_mutex_t），可以构造对象pthread_mutex_t mutx，mutx就是互斥锁对象。

（2）互斥锁的使用

以下是锁的一些成员函数和使用代码：

int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);

头文件：pthread.h

功能：初始化互斥锁。

参数：pthread_mutex_t *restrict mutex表示需要被初始化的锁的地址，const pthread_mutexattr_t *restrict attr表示锁的属性，一般都为nullptr。

返回值：取消成功返回0，取消失败返回错误码。

int pthread_mutex_destroy(pthread_mutex_t *mutex);

头文件：pthread.h

功能：销毁互斥锁。

参数：pthread_mutex_t *mutex表示需要被销毁的锁的地址。

返回值：销毁成功返回0，失败返回错误码。

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

如果是全局或static修饰的锁，使用上面语句初始化锁。

int pthread_mutex_lock(pthread_mutex_t *mutex);

头文件：pthread.h

功能：对lock到unlock的部分代码加锁（仅允许线程串行）。

参数：pthread_mutex_t *mutex表示需要加锁的锁指针。

返回值：加锁成功返回0，失败返回错误码。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

头文件：pthread.h

功能：标识走出lock到unlock的部分代码解锁（恢复并发）。

参数：pthread_mutex_t *mutex表示需要解锁的锁指针。

返回值：解锁成功返回0，失败返回错误码。

其实加锁和解锁可以圈定临界区的范围，临界区内的代码只允许同一时间有一个线程执行内部代码，只有该线程退出后才允许另一个线程执行该部分代码，外部的代码依旧允许并行。

我打个比方的话就像只容许一个人公共厕所，厕所只能进一个人，必须等里面的人使用完毕后另一个人才能进去，而外面的公共空间不受管制。

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(lock);
//临界区
//...
pthread_mutex_unlock(lock);

（3）代码的改造

对线程加锁需要做两件事：让所有线程都看到同一把锁，所有线程都使用同一把锁。

我们如果将锁定义在main函数内，那么只有主线程能看到该锁。所以我们在Thread类中增加一个锁指针，这时所有的线程就能使用同一把锁了。

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<stdio.h>
#include<vector>
using namespace std;

#define NUM 5

int tickets = 10;

class pthread_data
{
public:
    pthread_t tid;
    char buffer[64];
    pthread_mutex_t* pmtx;//锁指针
};

void* start_routine(void* args)
{
    pthread_data* p = (pthread_data*)args;
    string s;
    s += p->buffer;
    s += "Remaining tickets:";
    while(1)
    {
        pthread_mutex_lock(p->pmtx);//加锁
        if(tickets > 0)
        {
            sleep(1);
            --tickets;
            pthread_mutex_unlock(p->pmtx);//解锁
            printf("%s%d\n", s.c_str(), tickets);//不修改临界资源，可以不包含在内
        }
        else
        {
            pthread_mutex_unlock(p->pmtx);//解锁
            break;
        }
    }
    pthread_exit(nullptr);
}

int main()
{
    vector<pthread_data*> vpd;
    pthread_mutex_t mutx;//创建锁
    pthread_mutex_init(&mutx, nullptr);//初始化
    for(int i = 0; i<NUM; ++i)
    {
        pthread_data* pd = new pthread_data;
        pd->pmtx = &mutx;
        snprintf(pd->buffer, sizeof(pd->buffer), "thread%d buy ticket:",i+1);
        pthread_create(&(pd->tid), nullptr, start_routine, (void*)pd);
        vpd.push_back(pd);
    }

    for(auto& e : vpd)
    {
        pthread_join(e->tid, nullptr);
        delete e;
    }

    return 0;
}

注意加锁和解锁的区域只需要覆盖住对临界资源进行操作的代码，不要覆盖太大。

还有一定要注意解锁一定要覆盖到代码的执行路径，比如抢票代码else中如果没有解锁，那下面的所有执行就都加锁了，会对代码运行造成巨大影响。

再次运行，程序正常运行并退出，只是由于串行，程序的运行时间加长了。

因为正常的抢票往往是很短时间内就会有许多人访问，我们将sleep（1）换成usleep（1000）缩短睡眠时间。

我们会发现，大部分的票都被一个线程抢走了。

实际上，锁只保证互斥访问，不管执行线程的顺序。

thread5抢的多，说明该线程的竞争能力强，别的线程打不过它。

现在的抢票逻辑是抢到票解锁以后，该线程又直接去申请锁，这就导致了之前持有锁的线程更加容易再次申请到锁。

咱们再12306抢票成功后也不可能立刻再去抢，程序还需要做打印订单等等工作，所以我们在线程执行最后也睡眠一会儿。

这次就是正常的你来我往了。

3.锁的本质

（1）加锁对线程的影响

锁必须让所有线程都看到，所以锁本身就是共享资源。那谁来保护锁的安全呢？

锁是通过加锁和解锁操作的原子性来保证自身的安全的。

一个线程，如果成功申请锁，那么它就会继续向下执行，如果申请不成功呢？

我们发现进程线程都还在，但线程卡住了。

一个锁只能被申请一次，只有锁被释放才能再次申请。当一个线程申请锁失败，它就会阻塞不动。

所以我们此时就能理解CPU排队处理线程和串行的关系了：

当一个线程申请锁成功，进入临界区访问临界资源，其他线程要想进入临界区只能阻塞等待，等待该进程将锁释放。
当一个线程申请锁成功，进入临界区访问临界资源，在满足条件时也是可以被换下CPU的。而且锁还在该线程的受力，其他线程仍然无法申请锁成功。
操作系统内不存在锁的概念，所以调度器在调度轻量级进程的时候并不会考虑是否有锁。如果调度到了没有锁的进程，不进行处理就可以了。

所以站在其他线程的角度，锁只有两种状态：申请锁前和申请锁后。

站在其他线程的角度，当前持有锁的过程就是原子的。

（2）锁的原理

为了保证加锁的原子性，在大多数体系结构都提供了swap或者xchange汇编指令，保证加锁只需要一条汇编指令。

下面是加锁和解锁的伪代码（xchange是原子的）：

lock:
    movb %al, $0//将0写入al寄存器中
    xchange %al, mutex//将al寄存器的内容与锁的成员变量1交换
    if(al寄存器的内容 > 0)
    {
        return 0;
    }
    else
    {
        挂起等待;    
    }
    goto lock;

unlock:
    movb mutex, $1
    唤醒等待mutex的线程;
    return 0;

在CPU中有一个al寄存器，它也是锁的能正常运行的保证之一。

假设有两个线程，每个线程中都有加锁的代码。

首先CPU开始处理线程thread1，thread2等待被处理。由于thread1是第一次被处理，此时需要向al寄存器内写入0。

当线程thread1执行到加锁代码时，由于内存中的锁变量储存了一个变量1，所以al寄存器会与内存中的这个变量进行数据交换。

在执行临界区代码时，很可能thread1还没有解锁，该线程就被换下去了。但是CPU和寄存器只有一套，那么上下文数据就必须保存后由线程带走，同样al寄存器里的1就也被带走了。

当thread2也是初次执行，需要在al寄存器写入0。然后同样将al寄存器会与内存中的这个变量进行数据交换，但此时锁变量也是0，0和0交换完还是0。

由于交换后al寄存器内容不大于0，所以该线程申请不到锁，只能挂起等待。

由于thread2被挂起，所以thread1再次被执行，此时它的上下文数据被加载回寄存器，al寄存器数据为1，线程继续运行。

当thread1完成了临界区代码执行就需要将al寄存器的1还回给锁变量，thread1的al寄存器重新变回0。然后，唤醒等待锁的线程thread2，thread1又被挂起。

经过上面过程的描述，我们不难发现发现：

锁只能被一个线程持有，而且由于加锁是一条xchange汇编代码，操作是原子性的，也不需要担心线程切换的事情。
一旦一个线程申请到锁，因为即使该线程被切走，锁还是在它的上下文数据中。所以，其他线程无法拿到锁，只能挂起等待，只有等锁被释放时才能申请。
锁的工作本质上就是锁类变量中的一个标志位1在不同进程间传递的过程，只有申请到该标志位，或者说持有锁的线程才能执行。形象地说，利用锁达到线程串行类似于很多人抢一张入场券。
释放锁的过程对原子性的要求不高，因为只有持有锁的线程才能释放锁，未申请到锁的线程都在挂起。

4.封装锁

锁的成员函数名普遍偏长，也不方便使用，不如我们自己将锁封装，自己使用也方便。

mutex.h

#include<pthread.h>
class mutex
{
public:
    //构造函数
    mutex(pthread_mutex_t* p = nullptr)
        :_pmutx(p)
    {}
    //加锁
    void lock()
    {
        pthread_mutex_lock(_pmutx);
    }
    //解锁
    void unlock()
    {
        pthread_mutex_unlock(_pmutx);
    }    
private:
    pthread_mutex_t* _pmutx;
};

class LockGuard//这个类型变量的构造和销毁就可以执行加解锁
{
public:
    LockGuard(pthread_mutex_t* lock_p):_mutex(lock_p)
    {
        _mutex.lock();//构造函数内加锁
    }
    ~LockGuard()
    {
        _mutex.unlock();//析构函数内解锁
    }
private:
    mutex _mutex;
};

我们使用这个封装的锁修改代码。

#include<iostream>
#include"mutex.h"
#include<unistd.h>
#include<stdio.h>
#include<vector>
using namespace std;

#define NUM 5

pthread_mutex_t mutx = PTHREAD_MUTEX_INITIALIZER;//构建一个全局锁
int tickets = 10;

class pthread_data
{
public:
    pthread_t tid;
    char buffer[64];
};

void* start_routine(void* args)
{
    pthread_data* p = (pthread_data*)args;
    string s;
    s += p->buffer;
    s += "Remaining tickets:";
    while(1)
    {
        {
            LockGuard lock(&mutx);//左侧的语句块标识这个lock变量的生命周期
            //构造函数加锁，走出代码块时，该变量的声明周期结束，执行析构函数解锁
            //这样的加锁模式也叫做RAII加锁
            if(tickets > 0)
            {
                usleep(1000);
                --tickets;
                printf("%s%d\n", s.c_str(), tickets);//不修改临界资源，可以不包含在内
            }
            else
            {
                break;
            }
        }
        usleep(1000);
    }
    pthread_exit(nullptr);
}

int main()
{
    vector<pthread_data*> vpd;
    for(int i = 0; i<NUM; ++i)
    {
        pthread_data* pd = new pthread_data;
        snprintf(pd->buffer, sizeof(pd->buffer), "thread%d buy ticket:",i+1);
        pthread_create(&(pd->tid), nullptr, start_routine, (void*)pd);
        vpd.push_back(pd);
    }

    for(auto& e : vpd)
    {
        pthread_join(e->tid, nullptr);
        delete e;
    }

    return 0;
}

正确运行