【Linux系统】线程的互斥

互斥

互斥概念

多个线程能够看到的资源称为共享资源，那我们需要对这种资源进行保护，需要用到互斥！！！

见一见多线程访问的问题 --- 抢票问题

int tickets = 1000;

void route(const std::string& name)
{
    while(true)
    {
        if(tickets > 0)
        {
            //抢票过程
            usleep(1000); //ms -> 模拟抢票花费的时间
            printf("who:%s, tickets:%d\n", name.c_str(), tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }
}
int main()
{
    Thread t1("Thread-1", route);
    Thread t2("Thread-2", route);
    Thread t3("Thread-3", route);
    Thread t4("Thread-4", route);

    t1.Start();
    t2.Start();
    t3.Start();
    t4.Start();

    t1.Join();
    t2.Join();
    t3.Join();
    t4.Join();
    return 0;
}

理论上我们设定的是1000张票，枪到0结束，就不应该会出现0，-1，-2这种情况出现！！！

为什么？？？

认识和分析为什么会出现抢到负数的问题？？？

我们在判断票数时，判断的过程是不是计算？CPU是要进行调度计算的，那如何计算？

计算机的运算类型：1、算术运算 2、逻辑运算

CPU内，寄存器只有一套，但是寄存器里面的数据，可以有多套，属于线程私有，看起来放在了一套公共的寄存器内，但是属于线程私有，当他被切换的时候，他要带走自己的数据的！！！

回来的时候会恢复！！！而我们在执行票数--的操作时，其实在寄存器内部是要执行三步的，1.重读数据、2.--数据、3.读回数据，所以当我们有四个线程，a、b、c、d在跑时，a线程到达判断票树那行代码，此时票数为1，正常进入到达printf时，时间片轮转，b进程切换进来，此时b的票数读入的也是1，又到达printf等待打印，时间片再次轮转，进程切换到c，再轮转切换到进程d，那我们想怎样tickets再到达1时又串行的被--了四次，不就出现了负数！！！

如何解决呢？

互斥锁

认识锁和它的接口

Ubuntu系统手册查不到，Centos可以

其中pthread_mutex_t为互斥锁类型 -->任何时刻只允许一个线程进行资源访问，其中第一个接口只需传入我们设置的锁即可，第二个接口传入锁，第二个参数是各种属性，我们设为nullptr即可。

pthread_mutex_t 可设置为全局的，也可设置为局部，若是全局的或者是静态的，无需destroy。

我们常用第一个接口加锁，第三个解锁，第二个表示可在任何时刻解锁。

所谓的对临界资源进行保护，本质是对临界区代码进行保护！

我们对所有资源进行访问，本质都是通过代码进行访问的！所以保护资源，本质就是把访问资源的代码保护起来！

加锁和解锁本质就是把多线程从并行执行变为串行执行。

如果我们把加锁放在while循环外面会如何？我们多线程本来就是为了并发执行提高效率的，我们加到while外面，那循环里面不就变成了串行执行了吗，效率极低！！！

1.所以，加锁的范围，粒度一定要尽量的小，即代码行数尽量少！！！

2.任何线程要进行抢票，都得先申请锁，原则上不应该有例外

3.所有线程申请锁，前提是所有线程得看到这把锁，锁本身也是共享资源，加锁的过程，必须是原子的！！！

4.原子性：要么不做，要做就做完，没有中间状态，就是原子性。

5.如果线程申请锁失败了，我的线程要被阻塞

6.如果线程申请锁成功了，继续向后运行。

7.如果线程申请锁成功了，执行临界区的代码了，执行临界区代码可以切换吗？？？

可以，其他线程无法进入，因为我虽然被切换了，但是我没有释放锁啊！！！我可以放心的执行完毕，没有人能打扰我！

结论：所以对于其他线程，要么我没有申请锁，要么我释放了锁，对其他线程才有意义

我访问临界区，对其他线程是原子的！！！

下面是把锁设为局部锁的代码

mythread.hpp

#pragma once
#include<iostream>
#include<string>
#include<pthread.h>

namespace ThreadMoudle
{
    class ThreadData
    {
    public:
        ThreadData(const std::string &name, pthread_mutex_t *lock):_name(name),_lock(lock)
        {

        }
    public:
        std::string _name;
        pthread_mutex_t *_lock;
    };
    //线程要执行的方法
    typedef void (*func_t)(ThreadData *td);

    class Thread
    {
    public:
        void Excute()
        {
            std::cout << _name << "is running" << std::endl;
            _isrunning = true;
            _func(_td);
            _isrunning = false;
        }
    public:
        Thread(const std::string& name, func_t func, ThreadData *td) :_name(name), _func(func), _td(td)
        {
            std::cout << "create" << name << "done" << std::endl;
        }
        static void* ThreadRoutine(void* args)//新线程都会执行该方法
        {
            Thread* self = static_cast<Thread*>(args);//获得了当前对象
            self->Excute();
            return nullptr;
        }
        bool Start()
        {
            int n = ::pthread_create(&_tid, nullptr, ThreadRoutine, this);
            if(n != 0) return false;
            return true;
        }
        std::string Status()
        {
            if(_isrunning) return "running";
            else return "sleep";
        }
        void Stop()
        {
            if(_isrunning)
            {
                ::pthread_cancel(_tid);
                _isrunning = false;
                std::cout << _name << "Stop" << std::endl;
            }
        }
        std::string Name()
        {
            return _name;
        }
        void Join()
        {
            ::pthread_join(_tid, nullptr);
            std::cout << _name << "Joined" << std::endl;
            delete _td;
        }
        ~Thread()
        {

        }
    public:
        std::string _name;
        pthread_t _tid;
        bool _isrunning;
        func_t _func; //线程要执行的回调函数

        ThreadData *_td;
    };   
};

main.cc

static int num = 5;
int tickets = 1000;

void route(ThreadData* td)
{
    while (true)
    {
        pthread_mutex_lock(td->_lock);
        if (tickets > 0)
        {
            // 抢票过程
            usleep(1000); // ms -> 模拟抢票花费的时间
            printf("who:%s, tickets:%d\n", td->_name.c_str(), tickets);
            tickets--;
            pthread_mutex_unlock(td->_lock);
        }
        else
        {
            pthread_mutex_unlock(td->_lock);
            break;
        }
    }
}
int main()
{
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, nullptr);
    std::vector<Thread> threads;
    for(int i = 0; i < num; i++)
    {
        std::string name = "Thread-" + std::to_string(i+1);
        ThreadData* td = new ThreadData(name, &mutex);
        threads.emplace_back(name, route, td);
    }

    for(auto& thread:threads)
    {
        thread.Start();
    }

    for(auto& thread:threads)
    {
        thread.Join();
    }

    pthread_mutex_destroy(&mutex);
    return 0;
}

也可以对锁进行封装，利用局部对象出作用域析构的特性加锁解锁！

Lockguard .hpp

#pragma once
#include<pthread.h>

class LockGuard
{
public:
    LockGuard(pthread_mutex_t *mutex):_mutex(mutex)
    {
        pthread_mutex_lock(mutex);
    }
    ~LockGuard()
    {
        pthread_mutex_unlock(_mutex);
    }
private:
    pthread_mutex_t *_mutex;
};

main.cc

static int num = 5;
int tickets = 1000;

void route(ThreadData* td)
{
    while (true)
    {
        LockGuard lockguard(td->_lock);
        if (tickets > 0)
        {
            // 抢票过程
            usleep(1000); // ms -> 模拟抢票花费的时间
            printf("who:%s, tickets:%d\n", td->_name.c_str(), tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }
}
int main()
{
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, nullptr);
    std::vector<Thread> threads;
    for(int i = 0; i < num; i++)
    {
        std::string name = "Thread-" + std::to_string(i+1);
        ThreadData* td = new ThreadData(name, &mutex);
        threads.emplace_back(name, route, td);
    }

    for(auto& thread:threads)
    {
        thread.Start();
    }

    for(auto& thread:threads)
    {
        thread.Join();
    }

    pthread_mutex_destroy(&mutex);
    return 0;
}

原理角度如何理解这个锁呢？

pthread_mutex_lock(&mutex);

如何理解申请锁成功，运行你进入临界区？这是因为申请锁成功，pthread_mutex_lock函数会返回

如何理解申请锁成功，不允许你进入临界区？这是因为申请锁失败，pthread_mutex_lock函数不会返回，线程就阻塞了！

而unlock就是在lock内部被唤醒，重新申请锁！

互斥锁的底层实现理解

所以我们加锁时汇编层是需要把CPU内部的叫%al的寄存器清0，然后使用echgb指令把内存中的lock与CPU寄存器中的数据进行交换，（交换不是拷贝，只有一个“1”，持有“1”的就代表持有锁）这样该线程就拿到了一把锁！！！所以本质上xchgb这一条汇编指令就代表加锁！！！

1.CPU 的寄存器只有一套，被所有的线程共享，但是寄存器里面的数据，属于执行流的上下文，属于执行流私有的数据！

2.CPU在执行的时候，一定要有对应的执行载体 --- 线程&&进程

3.数据再内存中，是被所有线程所共享的！！

结论：把数据从内存移动到CPU寄存器中，本质是把数据从共享，变成线程私有！！！

所以加锁和解锁过程就是，第一个进去的线程把1从内存中交换到寄存器中，如果执行到判断代码，刚好时间片到了，进行切换，该线程就把自己的数据拿走，等下个时间片拿回来，在这段时间内，任何别的线程到达判断位置，都拿不到这个1，最后就会走else进行挂起等待，解锁时就把内存中的锁重新置回1，然后唤醒等待的线程继续执行即可！