void route(const std::string& name)
{
    while(true)
    {
        // 有票才抢
        if(tickets > 0)
        {
            usleep(1000); // 1ms -> 抢票花费时间
            printf("who: %s, get a ticket: %d\n", name.c_str(), tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }
}

主函数

// 模拟抢票 10000张
int tickets = 10000;

int main()
{
    // 1.创建4个线程
    Thread t1("thread-1",route);
    Thread t2("thread-2",route);
    Thread t3("thread-3",route);
    Thread t4("thread-4",route);

    // 2.启动4个线程
    t1.Start();
    t2.Start();
    t3.Start();
    t4.Start();

    // 3.终止4个线程
    t1.Join();
    t2.Join();
    t3.Join();
    t4.Join();

    return 0;
}

运行结果

抢票的代码确实执行完了，但是有一个问题，就是最终的票数竟然是负数，正常的逻辑是票数为0就不能再抢票了，这是为什么呢？

计算机的运算类型: 算术运算逻辑运算
CPU内，寄存器只有一套，但是寄存器里面的数据可以有多套
寄存器里面的数据看起来放在了一套公共的寄存器中，但是属于线程私有，当它被切换的时候，线程要带走自己的数据！回来的时候恢复数据
当线程2(tickets = 1)判断之后，线程被切换了两次，此时前面两个线程的数据会被保存，当当前线程执行完会继续执行前面的代码，次数就会出现最终tickets = -2的情况！！！

运行结果

1.2、解决多线程访问问题

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

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

互斥量mutex

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

1.2.1、互斥量的接口

初始化互斥量

方法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

销毁互斥量

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

注意：

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

互斥量加锁和解锁

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

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

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

1.2.2、互斥量接口的使用

1、全局锁(方法传name)

锁是全局的或者静态的，只需init，不需要destory。

抢票函数

// 模拟抢票 10000张
int tickets = 10000; // 共享资源，造成数据不一致问题

// 全局或者静态只需INIT，无需destory
pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER;

void route(const std::string &name)
{
    while (true)
    {
        pthread_mutex_lock(&gmutex); // 上锁
        // 有票才抢
        if (tickets > 0)
        {
            usleep(1000); // 1ms -> 抢票花费时间
            printf("who: %s, get a ticket: %d\n", name.c_str(), tickets);
            tickets--;
            pthread_mutex_unlock(&gmutex); // 解锁
        }
        else
        {
            pthread_mutex_unlock(&gmutex); // 退出循环之前解锁，否则会阻塞
            break;
        }
    }
}

主函数

static int threadnum = 4;

int main()
{
    std::vector<Thread> threads;
    // 1.创建线程
    for (int i = 0; i < threadnum; i++)
    {
        std::string name = "thread-" + std::to_string(i + 1);
        threads.emplace_back(name, route);
    }

    // 2.启动线程
    for (auto &thread : threads)
    {
        thread.Start();
    }

    // 3.终止线程
    for (auto &thread : threads)
    {
        thread.Join();
    }
    return 0;
}

运行结果

当我们运行程序的时候，可以明显看到抢票的过程变慢了，且最后抢到只有一张票了。

所谓的对临界资源进行保护，本质是对临界区代码进行保护！
我们对所有资源进行访问，本质都是通过代码进行访问的！

运行结果

解决历史问题：

1、加锁的范围，粒度一定要小(代码行数要少)
2、任何线程要进行抢票，都得先申请锁，原则上不应该有例外
3、所以线程申请锁，前提是所有线程都看到这把锁，锁本身也是共享资源 --- 加锁的过程，必须是原子的
4、原子性：要么不做，要做就做完，没有中间状态
5、如果线程申请锁失败，线程要被阻塞
6、如果线程申请锁成功，线程继续往后运行
7、如果线程申请成功了，执行临界区的代码，执行临界区代码期间，可以切换？
- 可以切换，其他线程无法进入！因为虽然线程被切换了，但是没有释放锁！
  - 所以线程可以放心的执行完毕，没有线程能打扰！

结论：

对于其他线程，要么我没有申请锁，要么我释放了锁，对其他线程才有意义！！ -> 线程访问临界区，对于其他线程是原子的。

2、局部锁(方法传结构体)

1、局部锁需要init且需要destory。

2、方法的参数调整成结构体之后，需要在原始的线程类加结构体成员变量，且修改构造函数。

3、需要函数指针类型

4、需改Excute函数

ThreadData类及函数指针

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); // 函数指针类型

Thread类

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;
    }
private:
    std::string _name;
    pthread_t _tid;
    bool _isrunning;
    func_t _func; // 线程要执行的回调函数
    ThreadData* _td;
}

抢票函数

// 模拟抢票 10000张
int tickets = 10000; // 共享资源，造成数据不一致问题

void route(ThreadData* td)
{
    while (true)
    {
        pthread_mutex_lock(td->_lock); // 上锁
        // 有票才抢
        if (tickets > 0)
        {
            usleep(1000); // 1ms -> 抢票花费时间
            printf("who: %s, get a ticket: %d\n", td->_name.c_str(), tickets);
            tickets--;
            pthread_mutex_unlock(td->_lock); // 解锁
        }
        else
        {
            pthread_mutex_unlock(td->_lock); // 退出循环之前解锁，否则会阻塞
            break;
        }
    }
}

主函数

static int threadnum = 4;

int main()
{
    pthread_mutex_t mutex; // 局部锁，需要init和destory
    pthread_mutex_init(&mutex, nullptr);

    std::vector<Thread> threads;
    // 1.创建线程
    for (int i = 0; i < threadnum; i++)
    {
        std::string name = "thread-" + std::to_string(i + 1);
        ThreadData *td = new ThreadData(name, &mutex); // new一个Thread对象，传局部锁
        threads.emplace_back(name, route,td);
    }

    // 2.启动线程
    for (auto &thread : threads)
    {
        thread.Start();
    }

    // 3.终止线程
    for (auto &thread : threads)
    {
        thread.Join();
    }

    pthread_mutex_destroy(&mutex);

    return 0;
}

运行结果

局部锁与全局锁的结果完全相同，都能正常完成任务！！！

3、RAII锁(构造上锁析构解锁)

LockGuard类

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

抢票函数

// 3.RAII
int tickets = 10000; // 共享资源，造成数据不一致问题

void route(ThreadData* td)
{
    while (true)
    {
        LockGuard lockguard(td->_lock); // RAII锁风格
        // 有票才抢
        if (tickets > 0)
        {
            usleep(1000); // 1ms -> 抢票花费时间
            printf("who: %s, get a ticket: %d\n", td->_name.c_str(), tickets);
            tickets--;
        }
        else
        {
            break;
        }
    }
}

运行结果

1.2.3、原理角度理解锁

互斥锁

原理：互斥锁用于保护临界区（Critical Section），确保同一时刻只有一个线程可以进入临界区。
实现：通常通过操作系统的内核提供的原子操作（如CAS，Compare-And-Swap）来实现。

1.2.4、实现角度理解

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