Linux(十一) 线程互斥

被资本驾驭

已于 2024-05-17 17:25:18 修改

阅读量808

点赞数 29

分类专栏： Linux 文章标签： linux 运维服务器

于 2024-05-16 16:45:15 首次发布

本文链接：https://blog.csdn.net/POSEidoNqs/article/details/138906320

版权

Linux 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

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

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

互斥量mutex

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。
但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

多个线程并发的操作共享变量，会带来一些问题。

#include <iostream>
#include <pthread.h> //原生线程库
#include <unistd.h>
#include <thread>
using namespace std;

// 如果多线程访问同一个全局变量，并对它进行数据计算，多线程会相互影响吗？
// 在并发访问的时候导致了我们数据不一致
int tickets = 10000;// 未来的临界资源，现在还不能保证任意时刻只允许一个执行流访问

void *getTickets(void *args)
{
    (void)args;
    while (true)
    {
        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);

    return 0;
}

此时运行结果会出现问题，为什么可能无法获得正确结果？

if 语句判断条件为真以后，代码可以并发的切换到其他线程，判断的本质也是计算的一种
usleep这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段
--ticket操作本身就不是一个原子操作

取出ticket--部分的汇编代码
objdump -d a.out > test.objdump
152 40064b: 8b 05 e3 04 20 00 mov 0x2004e3(%rip),%eax # 600b34 <ticket>
153 400651: 83 e8 01 sub $0x1,%eax
154 400654: 89 05 da 04 20 00 mov %eax,0x2004da(%rip) # 600b34 <ticket>

--操作并不是原子操作，而是对应三条汇编指令：

load：将共享变量ticket从内存加载到寄存器中
update: 更新寄存器里面的值，执行-1操作
store：将新值，从寄存器写回共享变量ticket的内存地址

要解决以上问题，需要做到三点：

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

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。

互斥量的接口

初始化互斥量
初始化互斥量有两种方法：

方法1，静态分配，锁是全局的，静态的，被static修饰的:
```
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
```

方法2，动态分配，锁是局部变量，并且没有被static修饰，用这个方法初始化，当不用这把锁后必须调用destory销毁锁

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t
*restrict attr);
参数：
mutex：要初始化的互斥量
attr：NULL

销毁互斥量

销毁互斥量需要注意：

使用PTHREAD_ MUTEX_ INITIALIZER初始化的互斥量不需要销毁
不要销毁一个已经加锁的互斥量
已经销毁的互斥量，要确保后面不会有线程再尝试加锁

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

调用pthread_ lock 时，可能会遇到以下情况:

互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功
发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。

加锁的时候我们希望加锁的力度越小越好，不要讲一些无关紧要的代码放入临界区

加锁之后，线程在临界区里，依然会被OS切换，但不会有问题，因为线程虽然被切换了，但是是持有锁被切换的，其他抢票的线程要执行临界区的代码必须先申请锁，但此时锁无法申请成功。所以不会让其他线程进入临界区，也就保证了临界区中的数据一致性。

初级原子性的体现：对于没有持有锁的线程看来对我有利的只有两种情况：1.线程1没有持有锁(什么都没做)2.线程1释放锁(做完)，此时我可以申请锁。

加了锁后执行临界区代码一定是串行的

改进上面的售票系统:

#include <iostream>
#include <pthread.h> //原生线程库
#include <unistd.h>
#include <thread>
#include <string>
#include <time.h>
using namespace std;
#define THREAD_NUM 5
class ThreadData
{
public:
    ThreadData(const string& n,pthread_mutex_t* pm)
        :name(n)
        ,pmtx(pm)
    {}
public:
    string name;
    pthread_mutex_t* pmtx;

};
int tickets = 10000;
void *getTickets(void *args)
{
    ThreadData* td = (ThreadData*)args; 
    while (true)
    {
        // 临界区
        pthread_mutex_lock(td->pmtx);
        if (tickets > 0) // 临界区 1.判断的本质也是一种计算，逻辑计算，CPU只能进行算术运算和逻辑运算
        {
            usleep(1000);
            printf("%s : %d\n",td->name.c_str(),tickets);
            tickets--;// 2.也可能出现
            pthread_mutex_unlock(td->pmtx);
        }
        else
        {
            pthread_mutex_unlock(td->pmtx);
            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_mutex_t mtx;
    pthread_mutex_init(&mtx,nullptr);
    pthread_t t[THREAD_NUM];
    for(int i = 0;i < THREAD_NUM;i++)
    {
        string name = "thread ";
        name += to_string(i + 1);
        ThreadData* td = new ThreadData(name,&mtx);
        pthread_create(t+i,nullptr,getTickets,(void *)td);

    }
    for(int i = 0;i <THREAD_NUM;i++)
    {
        pthread_join(t[i],nullptr);
    }
    pthread_mutex_destroy(&mtx);    
    return 0;
}

互斥量实现原理探究

一个问题
要访问临界资源，每个线程必须申请一把锁，每个线程必须先看到(访问)同一把锁，锁本身是不是就是一种共享资源谁来保证锁的安全？为了保证锁的安全，锁的申请和释放必须是原子的。自己保护，在设计时通过一行汇编进行保护

经过上面的例子，大家已经意识到单纯的i++或者++i都不是原子的，有可能会有数据一致性问题。
为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。现在我们把lock和unlock的伪代码改一下。

可重入VS线程安全

概念

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