一.问题:数据不一致(混乱/不安全)

在线程中，全局变量就相当于一个共享资源，每个线程都可以看到，并且每个线程都可以访问，一旦多线程访问这个共享资源，就可能会出现一些问题。
会出现什么问题呢？为什么会出现问题呢？如何解决问题呢？
首先多线程访问共享资源，通常会出现数据不一致问题。为什么会出现呢？

我们以上面的模拟抢票过程来简述：

1.多线程并发计算不安全

多线程并发去计算的过程是不安全的，为什么呢？因为计算的过程就是不安全的。最简单的计算比如++，–,在代码层面只是简单的一行，但在编码层面它会转成3句汇编。

计算机中–计算的过程是被分成3步的：
1.首先会将变量从内存读入到cpu的寄存器中。
2.然后在CPU的内部进行–计算
3.将计算结果再写回内存。

而–计算被分成3步的话，那么就会存在一个线程计算一半中，然后被切换走的场景。这个计算过程是不安全的，因为还没计算完，就被切换走了。
而我们知道，线程被切换走时，不仅要将PCB给带走，还需要将硬件上下文保存带走。线程上下文中保存的就是上次的数据，这些数据从哪里来的？是寄存器中的！

2.将数据加载到寄存器的本质

线程在执行计算的时候，将共享资源从内存加载到寄存器中，然后进行运算，如果突然该线程被切换走了，那么该线程就要拿着它的PCB和硬件上下文滚蛋。新线程将自己的数据放到CPU的寄存器中，当运行一段时间后，老线程又被唤醒，老线程首先做的是将自己的上下文恢复到CPU上，然后再进行计算。
而线程的上下文中的数据都是从寄存器中获取的。所以线程将共享资源从内存加载到寄存器的本质就是：将数据的内容，变成自己的上下文，也就是以拷贝的方式，给自己拿了一份，不然被切换走了，下次回来怎么恢复数据呢？

所以多线程并发计算的过程是不安全的，会导致数据不一致。

场景1：多线程并发计算
比如一个线程正在计算一个变量1000，要将做–计算。该线程刚把数据从内存中加载到寄存器中，还没来得及计算，就被切换走了，走的时候线程上下文带走了。
然后线程2就被调度起来进行运算，他很幸运，一直在执行着–的三步骤，循环了990次，在991次时，刚将变量10从内存加载到cpu寄存器时，就被切换了，原来的线程被唤醒，该线程被唤醒后第一步做的就是将上下文恢复到寄存器里，也就是将原来的数据1000又恢复到寄存器上了，然后该线程就开始执行运算，这就导致了数据不一致问题了！

---

多线程并发计算的过程是不安全的，还会导致数据不安全。

场景2：多线程并发比较(比较也是属于计算)
比较是逻辑运算，需要加载到CPU中
我们想要变量小于0时就不要–了，大于0时再去减减。但多线程并发执行时，结果却不是这样的。
最后的结果都减到负数却还在减减计算。这是为什么呢？
就是因为多线程并发访问共享资源造成的，比如最后变量ticket为1了，3个线程同时比较变量，也就是同时将变量从内存加载到寄存器上(而这个过程本质就是将数据拷贝到线程自己的上下文中)，然后还没开始进行比较，其中2个线程被切换，只有一个线程在运行，这三个被切换掉的线程的上下文中都保存着相同的数据1，而真正执行的线程发现该变量满足条件，就继续减减了，最后变量变成0。下一次，三个被切换的线程同时被唤醒，第一步就是将自己的上下文恢复到寄存器中，这是寄存器中的数据就是1，然后CPU比较发现这三个线程都满足计算条件，就都进行减减计算了，所以数据就从0减到1减到2，最后减到3。这就是多线程并发访问导致的后果。

---

场景3：多执行流并发打印，显示屏上显示混乱
因为对于多线程来说，往显示屏上打印，就是一个往一个文件里写入，这个文件就相当于共享资源，它们都可以使用，一起使用的后果就是数据混乱打印，无序，信息交叉

也就是将这个共享资源保护起来，让它具备原子性。

二.解决方法–互斥锁

导致上面数据不一致问题的根本在于多线程并发访问，所以不要让多线程并发访问就可以解决问题，而这样的解决概念我们称为互斥，就是在任何时刻，只允许一个执行流访问共享资源的行为，我们称为互斥。而如何实现互斥呢？我们是根据锁来实现的，使用锁，我们就可以保证执行流在访问共享资源时，只有一个执行流能够访问，等该执行流访问完后，其他执行流才可以接着访问。

概念---->对共享资源的任何访问，保证任何时候只有一个执行流访问—互斥
实现方法—>锁

三.互斥锁的概念与接口

锁的出现是为了实现线程之间互斥。而互斥也是具有范围的，并不是线程所有部分都要互斥，只是针对共享资源线程之间互斥，在任何时刻只允许一个执行流访问的资源就叫做临界资源。也就是只有对共享资源做了保护，它才叫做临界资源。而访问临界资源的那部分代码就被称为临界区。
加锁的本质就是对共享资源保护，让它变成临界资源，让线程在临界区只能串联的形式执行。不能并发执行。
而且一旦加锁，可能会较低线程的并发度，所以我们的加锁有一个原则：尽量要保证临界区代码要越少越好。(毕竟线程发明出来就是为了调高并发度)

1.定义锁

在内核中，库给我们提供了锁的数据类型pthread_mutex_t

定义一把锁，有两种方式，要么定义成局部锁，要么定义成全局锁。
定义成局部锁，就需要对锁来初始化和销毁。
而定义成全局锁，只需要赋值一个宏，就可以完成定义和初始化了。

2.加锁/解锁

将锁定义好后，就可以对资源进行加锁了，在共享资源的前面加锁，最后面解锁，这样就相当于对共享资源加锁了。
加锁使用lock，解锁使用unlock，参数就是对应的锁地址。

共享资源一旦被加锁了，执行流要想访问该临界资源，就需要申请锁，只有申请到锁了，才可以访问临界资源，往后执行，而锁资源只有一把，一旦被申请走了，其他线程就无法申请到了，只能阻塞等待锁资源就绪。

加锁后，互斥锁就会对临界区进行保护。
【问题1】请简述什么是线程互斥，为什么需要互斥

线程互斥指的是在多个线程间对临界资源进行争抢访问时有可能会造成数据二义，因此通过保证同一时间只有一个线程能够访问临界资源的方式实现线程对临界资源的访问安全性

【问题2】加完锁后，在临界区中，线程可以被切换吗？

可以的！线程虽然被切换走了，但它是持有锁被切换走的，锁也被带走了，这块临界资源其他线程还是不能访问的。
通过加锁，就能保证当前线程在访问临界区期间，对于其他线程来说是原子的。谁持有锁，访问它的过程就是原子的。
其他线程不关心你拿到锁干了什么，只关心你拿没拿到锁，或者释放没释放锁。

四.互斥锁实现原理与应用

我们通过锁来保护了共享资源，让它不会被多线程并发访问。线程只有获取锁资源，才能访问临界资源，那么对于锁来说，它不也是一个共享资源吗？它来保护临界资源，那么谁来保护它呢？

不用担心，申请锁和释放锁，本身就是原子的，不会被中断，要么执行完，要么不执行。它本身就被设计成了原子性操作，那么这是如何做到的呢？

1.原理：exchange指令

加锁的底层逻辑：

将0放在al这个寄存器中，然后到内存中用al与mutex变量互相交换。al中就获取到锁资源，而内存中的mutex就变成0了。

锁本身就是一个变量，在访问它时，需要将它从内存读取到cpu的寄存器上，而这一个过程本质就是将该数据的内容拷贝到线程的硬件上下文中。这里不是单纯的读取，而是使用交换exchange指令，将内存中的数据交换到cpu的寄存器中。也就是将数据交换到线程的硬件上下文中。

因为共享资源就只有一个，一旦交换完，就属于线程私有的了，为什么这么说呢？

因为每个线程的上下文都是独立私有的，你将锁资源交换从内存交换出来，变成自己的上下文内容，而锁资源只有一份，内存给你一个锁资源，你给内存一个0，其他线程如果想再从内存中交换，只能交换到0，而不能交换到锁资源了。

解锁底层逻辑：

2.应用：同步场景

在很多场景下需要使用互斥，而互斥有时候并不能完全解决好问题，就比如同步问题。其实互斥是一种解决方案，它也是有局限性的，在某些场景下，我们需要在互斥的基础上再应用同步，才能解决问题。
那么什么叫同步呢？
就是让所有的线程按照一定的顺序来获取资源的行为，叫做同步。同步是在互斥的基础上进行的。
是什么问题导致需要同步来解决呢？
就比如我们的抢票程序中存在一个细节，我们创建了3个线程来共同抢票，因为多线程并发抢票会出现问题，所以我们给共享资源加锁保护，让线程之间互斥，理论上应该是这三个线程轮次抢票，但程序跑起来后，却不是这样：是线程1一直在抢票，其他两个线程没有在抢票，这是为什么呢？

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <vector>
#include "LockGuard.hpp"
using namespace std;

#define NUM 4 // 创建多线程

//定义全局锁
//方式定义并且初始化
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
class threadData
{
public:
    threadData(int number)
    {
        _threadname = "thread-" + to_string(number);
    }

public:
    string _threadname;
};
int ticket=1000;//全局变量，共享资源
void * Getticket(void* args)
{

    threadData *td=static_cast<threadData*>(args);//可以知道是哪一个线程执行的
    const char* name=td->_threadname.c_str();
    //线程持续抢票
    while(true)
    {
        //加锁，锁共享资源，即临界区
      
        pthread_mutex_lock(&lock);//线程申请成功锁后，才能往后执行，其他没有锁的线程就会在阻塞挂起
        if(ticket>0)
        {
            usleep(1000);//增加其他进程调度的机会
            printf("%s, get a ticket: %d\n",name,ticket);
            ticket--;
            pthread_mutex_unlock(&lock);//解锁
        }
        else 
        {
            pthread_mutex_unlock(&lock);
            break;
        }
        
        //usleep(15);//强完票，我们还需要做一些事情，不是抢完立即再去强实多线程还要执行得到票之后的后续动作
    }
    printf("%s ...quit\n",name);
    return nullptr;
}
//多线程并发执行会存在问题----数据不一致问题
//如何解决呢？-->互斥锁,将共享资源加锁起来，不许多执行流一起访问

int main()
{
    // 1.如何创建多线程呢？--创建多线程，主线程要想找到每个线程，就需要保存每个线程的tid,用vector保存
    // 主线程在创建多线程之前，给每个线程都初始些属性，比如名字等
    vector<pthread_t> vp;//存储每个线程的tid
    vector<threadData*> vtd;//存储每个线程的基本属性--名字
    
    for (int i = 0; i < NUM; i++)//同时创建了四个线程,这四个线程都会执行GEtticket
    {
       
        pthread_t tid;
        threadData *td = new threadData(i);
        vtd.push_back(td);
        pthread_create(&tid, nullptr, Getticket,vtd[i]);
        vp.push_back(tid);
    }
    
     //多线程创建完，主线程还需要等待这些多线程,根据线程的tid等待
     for(int i=0;i<vp.size();i++)
     {
         pthread_join(vp[i],nullptr);
     }

     //还需要释放申请的资源
     for(int i=0;i<vtd.size();i++)
     {
        delete vtd[i];
     }

     return 0;
}

这里就存在一个事实：不同线程对于锁资源的竞争能力可能会不同，有的线程因为竞争能力很强，会一直抢到锁资源，然后执行后面的代码，释放锁资源，然后又抢到锁资源，执行代码，释放锁资源…….

比如说当前线程1距离锁最近，在持有锁阶段，其他线程还在挂起，当线程1刚释放锁资源时，其他线程还需要被唤醒，而线程1直接就可以获取到，所以竞争能力很强。

而其他线程由于长时间不能获取到锁资源就会导致饥饿问题。

1.所以在纯互斥环境下，如果锁资源分配不够合理，就容易出现其他线程饥饿问题。
2.但并不是说只要有互斥就会存在饥饿，更不是说互斥不好，而是在适合纯互斥的场景下去用互斥。

所以这里我们就可以利用同步来解决问题，问题根源就是因为线程1刚把锁释放，就又去申请锁，所以我们让线程1在把锁释放之后，不要再去申请锁，而是去一个队列里去排队，这样其他线程就会有机会来获取锁资源，然后执行代码，释放锁资源后，也去队列里排队，这样就能保证每个线程都可以获取锁资源。

其实这里是代码方面存在一些问题，在抢票之后，不应该立即再去抢票，应该需要做一些动作的，比如买完票后，需要将自己的身份信息核对等等，所以我们这里休眠一会代替执行一些动作。有了这个时间间隙，线程之间切换的几率就会大大提高。

3.应用：封装锁

我们可以将加锁，解锁等动作再封装简单点

#pragma once

#include <pthread.h>


class LockGuard
{
public:
    LockGuard(pthread_mutex_t *lock):_lock(lock)
    {
pthread_mutex_lock(_lock);//加锁                                                                                                                                                                               NNNNNNNNNNNNNNNNNNNNNNNNN NN N N NN N  NNNNNNNNNNNNNNNNNNNNNNNN                                                                                                                                                                                                                                                                          ngmNMN N N N N MN  
    }
     
    ~LockGuard()
    {
        pthread_mutex_unlock(_lock);//解锁
    }
private:
   pthread_mutex_t *_lock;
};

要注意，这里并没有封装真正的锁，而是锁的指针，锁的定义需要外界传进来初始化。

五.存在问题：死锁

加锁也会存在问题，那就是死锁。
什么叫死锁呢?就是你当前拥有一把锁，然后又去申请别人的锁资源，别人也申请你的锁资源，你们两都不释放锁资源，就造成闭环死锁。

这是存在多把锁的情况，而只有一把锁，也会存在死锁，那就是你当前拥有锁，然后又去申请锁资源，就会申请失败，然后被挂起，但你挂起的线程是持有锁的，所以其他线程也无法申请锁，都会失败。

那么如何解决死锁问题呢？破坏形成死锁的必要条件！