多线程执行的问题

先看一段代码

int tickets=10000;

void* buytickets(void* args)
{
    char* name = (char*)args;

    while(1)
    {
        if(tickets>0)
        {
            cout<<name<<"] tickets:"<<tickets<<endl;
            tickets--;
        }
        else
        {
            cout<<name<<"] tickets:"<<tickets<<endl;
            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_t pth1;
    pthread_t pth2;
    pthread_t pth3;
    pthread_t pth4;
    
    pthread_create(&pth1,nullptr,buytickets,(void*)"thread 1");
    pthread_create(&pth2,nullptr,buytickets,(void*)"thread 2");
    pthread_create(&pth3,nullptr,buytickets,(void*)"thread 3");
    pthread_create(&pth4,nullptr,buytickets,(void*)"thread 4");

    pthread_detach(pth1);
    pthread_detach(pth2);
    pthread_detach(pth3);
    pthread_detach(pth4);
    

    sleep(10);
    return 0;
}

上述代码会有什么问题呢？

tickets会有负数的情况出现
为什么呢？

在执行判断if()语句时，CPU会经历上面两个阶段，先从内存中读取数据，在进行判断。在上面任何一个阶段进程可能被切走。



这就是为什么会产生tickets为负数的原因

注：tickets- - 也会有上述问题，这里就不再重复阐述

如何解决？在解决之前，我们先介绍几个概念

Linux线程互斥

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

互斥量mutex

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

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

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

要做到这三点，本质上就是需要一把锁。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：nullptr

销毁互斥量

销毁互斥量需要注意：

使用 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;

int tickets=10000;

void* buytickets(void* args)
{
    char* name = (char*)args;

    while(1)
    {
        pthread_mutex_lock(&mutex);

        if(tickets>0)
        {
            cout<<name<<"] tickets:"<<tickets<<endl;
            tickets--;
            pthread_mutex_unlock(&mutex);

        }
        else
        {
            cout<<name<<"] tickets:"<<tickets<<endl;
            pthread_mutex_unlock(&mutex);

            break;
        }
    }
    return nullptr;
}

int main()
{
    pthread_t pth1;
    pthread_t pth2;
    pthread_t pth3;
    pthread_t pth4;
    
    pthread_create(&pth1,nullptr,buytickets,(void*)"thread 1");
    pthread_create(&pth2,nullptr,buytickets,(void*)"thread 2");
    pthread_create(&pth3,nullptr,buytickets,(void*)"thread 3");
    pthread_create(&pth4,nullptr,buytickets,(void*)"thread 4");

    pthread_detach(pth1);
    pthread_detach(pth2);
    pthread_detach(pth3);
    pthread_detach(pth4);
    

    sleep(10);
    return 0;
}