【Linux线程篇】线程安全守护者——线程互斥(互斥锁)

W…Y

于 2024-07-23 19:15:06 发布

阅读量947

点赞数 7

分类专栏： Linux 文章标签： linux 服务器运维 c++ 算法 ai chatgpt

本文链接：https://blog.csdn.net/m0_74755811/article/details/140591198

版权

Linux 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

引言

我们已经学习了线程操作，知道了线程的相关系统调用。但是在线程中一定会有一些安全问题，现在我们给与一个场景：当我们给一些线程派发抢车篇的任务时，也就是说让多个线程访问同一份资源时，会怎么样呢？我们通过一个代码来模拟抢车票的过程。

首先C++11中对我们Linux中的pthread库进行了封装，我们自己模拟了一份thread库：

#ifndef __THREAD_HPP__
#define __THREAD_HPP__
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <functional>
using namespace std;
namespace ThreadModule
{
    template <typename T>
    using func_t = function<void(T)>;

    template <typename T>
    class Thread
    {
    public:
        Thread(func_t<T> func, T &data, const string name = "none-name")
            : _func(func), _data(data), _threadname(name), _stop(true)
        {
        }
        void Excute()
        {
            _func(_data);
        }
        static void *threadtoutine(void *args)
        {
            Thread<T> *self = static_cast<Thread<T>*>(args);
            self->Excute();
            return nullptr;
        }
        bool Start()
        {
            int n = pthread_create(&_tid, nullptr, threadtoutine, this); 
            if (!n)
            {
                _stop = false;
                return true;
            }
            else
            {
                return false;
            }
        }
        void Detach()
        {
            if (!_stop)
            {
                pthread_detach(_tid);
            }
        }
        void Join()
        {
            if (!_stop)
            {
                pthread_join(_tid,nullptr);
            }
        }
        std::string name()
        {
            return _threadname;
        }
        void Stop()
        {
            _stop = true;
        }
        ~Thread()
        {
        }

    private:
        pthread_t _tid;
        string _threadname;
        T _data; 
        func_t<T> _func;
        bool _stop;
    };
}

#endif

我们使用我们自己的thread库模拟了抢车票的任务：

#include <iostream>
#include <unistd.h>
#include <vector>
#include "Thread.hpp"

using namespace std;
using namespace ThreadModule;
int g_tickets = 10000;
const int num = 4;
class ThreadData
{
public:
    ThreadData(int &tickets, const std::string &name)
        : _tickets(tickets), _name(name), _total(0)
    {
    }
    ~ThreadData()
    {
    }

public:
    int &_tickets; // 所有的线程，最后都会引用同一个全局的g_tickets
    std::string _name;
    int _total;
};
void route(ThreadData *td)
{
    while (true)
    {
        {

            if (td->_tickets > 0) // 1
            {
                usleep(1000);
                printf("%s running, get tickets: %d\n", td->_name.c_str(), td->_tickets); // 2
                td->_tickets--;                                                           // 3
                td->_total++;
            }
            else
            {

                break;
            }
        }
    }
}

int main()
{
    vector<Thread<ThreadData *>> threads;
    vector<ThreadData *> datas;
    for (int i = 0; i < num; i++)
    {
        std::string name = "thread-" + std::to_string(i + 1);
        ThreadData *td = new ThreadData(g_tickets, name);
        threads.emplace_back(route, td, name);
        datas.emplace_back(td);
    }
    for (auto &thread : threads)
    {
        thread.Start();
    }

    // 3. 等待一批线程
    for (auto &thread : threads)
    {
        thread.Join();
        // std::cout << "wait thread done, thread is: " << thread.name() << std::endl;
    }
    for (auto data : datas)
    {
        std::cout << data->_name << " : " << data->_total << std::endl;
        delete data;
    }

    return 0;
}

这样我们就可以利用4个线程来将我们10000张票进行抢购，我们的运行逻辑很简单，就是当线程进入任务函数时tickes--，直到tickes数量小于等于0时结束。这时就会发现可能会抢到-1或-2张票，也就是说抢到了100002张票，这就是问题所在。

这就是对全局tickets没有进行临界资源保护，导致数据不一致问题！！！

这就会引出我们今天的话题，线程的互斥与同步。

Linux线程互斥

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

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

互斥量mutex

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

所以我们可以解释抢票为什么能抢到负数：

这个函数中的临界资源就是我们的tickets，这个函数中有三个地方提到了临界资源。首先我们线程进入时都要对tickets进行判断，如果满足判断就要在printf中进行第二次访问，最后我们又对tickets进行了--操作。假设我们的tickets现在只有一张，我们现在有4个线程。当thread-1进入函数时满足tickets大于0进入任务后还没有进行--操作时间片到了，thread-1被切换走并会带走cpu中上下文数据，thread-2线程与thread-1过程相同，一直到下一次thread-1切换到cpu中会将上下文数据放回cpu中继续使用，执行完if语言中的所有操作结束。但是到后面剩下三个线程都已经进入if语句中并不需要判断，但是tickets已经被thread-1减成了0。所以剩下三个线程继续执行--操作才会有对应的负数，以及超过最后10000张票。总体来说tickets == 1时让多个线程已经进入抢票的逻辑中来!!!

总结：

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，静态分配: pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
方法2，动态分配:

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调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。

还有一种情况是函数调用失败，直接出错返回。

所以我们就可以将我们的抢票代码实现加锁操作，但是我们不是给临界资源加锁，而是给临界区的代码加锁！！！

我们加锁本质就是将多线程的并行执行变成串行执行的过程，所以加锁的力度肯定要越细越好！！

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//申请一个全局锁
void route(ThreadData* td)
{
    while (true)
    {
        {
            pthread_mutex_lock(&mutex);
            if (td->_tickets > 0) // 1
            {
                usleep(1000);
                printf("%s running, get tickets: %d\n", td->_name.c_str(), td->_tickets); // 2
                td->_tickets--;                                                           // 3
                td->_total++;
                pthread_mutex_unlock(&mutex);
            }
            else
            {
                pthread_mutex_unlock(&mutex);
                break;
            }
        }
    }
}

我们也可以在主函数中加局部锁，并且在类中加入锁变量，我们就可以直接使用：

class ThreadData
{
public:
    ThreadData(int &tickets, const std::string &name, pthread_mutex_t& mutex)
        : _tickets(tickets), _name(name), _total(0),_mutex(mutex)
    {
    }
    ~ThreadData()
    {
    }

public:
    int &_tickets; // 所有的线程，最后都会引用同一个全局的g_tickets
    std::string _name;
    int _total;
    pthread_mutex_t &_mutex;
};
// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//申请一个全局锁
void route(ThreadData* td)
{
    while (true)
    {
        {
            pthread_mutex_lock(&td->_mutex);
            if (td->_tickets > 0) // 1
            {
                usleep(1000);
                printf("%s running, get tickets: %d\n", td->_name.c_str(), td->_tickets); // 2
                td->_tickets--;                                                           // 3
                td->_total++;
                pthread_mutex_unlock(&td->_mutex);
            }
            else
            {
                pthread_mutex_unlock(&td->_mutex);
                break;
            }
        }
    }
}

int main()
{
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex,nullptr);

    vector<Thread<ThreadData*>> threads;
    vector<ThreadData*> datas;
    for (int i = 0; i < num; i++)
    {
        std::string name = "thread-" + std::to_string(i + 1);
        ThreadData *td = new ThreadData(g_tickets, name, mutex);
        threads.emplace_back(route, td, name);
        datas.emplace_back(td);
    }
    for (auto &thread : threads)
    {
        thread.Start();
    }

    // 3. 等待一批线程
    for (auto &thread : threads)
    {
        thread.Join();
        // std::cout << "wait thread done, thread is: " << thread.name() << std::endl;
    }
    for (auto data : datas)
    {
        std::cout << data->_name << " : " << data->_total << std::endl;
        delete data;
    }
    pthread_mutex_destroy(&mutex);
    return 0;
}

当然我们也可以使用RAII的模式对锁进行封装：

#ifndef __THREAD_HPP__
#define __THREAD_HPP__
#include<iostream>
#include<pthread.h>
using namespace std;
class LockGuard
{
public:
    LockGuard(pthread_mutex_t *mutex)
        :_mutex(mutex)
    {
        pthread_mutex_init(_mutex, nullptr);
    }
    ~LockGuard()
    {
        pthread_mutex_destroy(_mutex);
    }
private:
    pthread_mutex_t *_mutex;
};

#endif

这样我们的抢票逻辑就完成了，但是我们现在实在ubutun的环境下进行，每一个版本的pthread库实现都不太相同，竞争锁是自由竞争的，竞争锁的能力太强的线程会导致其他线程抢不到票，所以导致有些版本下进程会出现饥饿问题。

互斥量实现原理探究

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

下面是加锁解锁的伪代码：

其实mutex锁就类似一个变量，首先CPU中有一个寄存器%al，将0放入这个寄存器中去。然后将mutex值(一般是1)与%al寄存器中的值进行交换(这里的交换是原子性的，因为是汇编级语句)。线程的执行期间都是可以被切换走的，但是这里无论从哪个语句被切走都不会产生问题。

所以加锁的实质是将一个共享的数据mutex，转入CPU内部寄存器后，被某一个线程通过上下文数据给带走。这样就可以将数据从一个公共的变成一个私有的数据，禁止别人进行访问！！！

所以当在临界区进行加锁后，无论这个线程工作还是休眠，都会持有那把锁，其他线程不可能访问临界区的任何资源——这养的线程是安全的。

可重入VS线程安全

概念

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

常见的线程不安全的情况

不保护共享变量的函数
函数状态随着被调用，状态发生变化的函数
返回指向静态变量指针的函数
调用线程不安全函数的函数

常见的线程安全的情况

每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的
类或者接口对于线程来说都是原子操作
多个线程之间的切换不会导致该接口的执行结果存在二义性

常见不可重入的情况

调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的
调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构
可重入函数体内使用了静态的数据结构

常见可重入的情况

不使用全局变量或静态变量
不使用用malloc或者new开辟出的空间
不调用不可重入函数
不返回静态或全局数据，所有数据都有函数的调用者提供
使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据

可重入与线程安全联系

函数是可重入的，那就是线程安全的
函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题
如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的。

可重入与线程安全区别

可重入函数是线程安全函数的一种
线程安全不一定是可重入的，而可重入函数则一定是线程安全的。
如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生死锁，因此是不可重入的。

我们又回到刚才的问题，我们现在实在ubutun的环境下进行，每一个版本的pthread库实现都不太相同，竞争锁是自由竞争的，竞争锁的能力太强的线程会导致其他线程抢不到票，所以导致有些版本下进程会出现饥饿问题，这就要引出线程同步问题，线程同步我们在下一篇博客中说明！

以上就是本次全部内容，感谢大家观看

W…Y

关注

7
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Linux线程篇】线程安全守护者——线程互斥(互斥锁)

线程互斥是确保在多线程环境中，对共享资源的访问是串行化的机制。这是通过互斥锁（mutexes）实现的，互斥锁是一种同步原语，用来保护共享数据不被多个线程同时修改，从而避免数据竞争和一致性问题。互斥锁的工作原理是，当一个线程想要访问共享资源时，它必须首先尝试锁定互斥锁。如果互斥锁已经被其他线程锁定，请求线程将被阻塞，直到互斥锁被释放。一旦互斥锁被当前线程锁定，该线程就可以安全地访问共享资源。访问完毕后，线程必须释放互斥锁，允许其他线程访问资源。
复制链接

扫一扫