Linux系统编程6（线程互斥，锁，同步，生产消费模型）

上篇文章介绍完线程的概念后，我们将在这篇文章中初步探讨线程编程以及线程应用中的问题，这篇文章将以抢票系统为例，贯穿整篇文章。笔者将介绍在多线程编程中会出现的问题，什么是同步？什么是互斥？为什么多线程编程常有加锁的概念，什么又是生产者和消费者模型，读完这篇文章，你会得到相应的答案，笔者这里强烈建议各位把文中给出的demo示例自己实现一遍

多线程这部分必须要理论和实操相结合，并不像前面虚拟地址空间，页表这些理论性的知识，只要理解就可以了

初步应用多线程

多线程是一朵带刺的玫瑰，在享受它带来方便的同时要煞费思量多线程带来的问题

接下来咱们以一个实例来刨析使用线程究竟会带来哪些问题，咱们模拟一个抢票的场景，在main函数里创建一个次线程，然后主线程和次线程同时进行抢票，代码如下

#include<pthread.h>
#include<iostream>
#include<unistd.h>
int counter = 100;
void* start_routine(void* args)
{   
    while(counter > 0){
        counter--;
        std::cout << "抢票用户：次线程，剩余票数: " << counter << std::endl;
    }
    return nullptr;
}
int main()
{   
   pthread_t thread;
   pthread_create(&thread, NULL, start_routine, NULL);
    while ( counter > 0){
        counter--;
        std::cout << "抢票用户：主线程， 剩余票数：" << counter << std::endl;
    }
    pthread_join(thread, NULL);
    return 0;
}

代码很简单，看运行结果

可以发现，所有的票都是主线程抢到的，次线程一张票都没有抢到，这是因为次线程还没有创建完的时候，CPU不断执行主线程的循环，把票抢完了

我们要模拟出多个线程间交叉执行的情况，而不是某一个线程把所有的票都抢完了，想要模拟出这个场景，我们就得人为让CPU频繁的调度

所以，我们需要在抢票循环之前加上sleep，当某个线程准备开抢时，先休眠一会，被OS挂起，给其他线程启动的机会。但是我们不敢直接用sleep，因为该函数是以秒为单位的，以CPU的速度，如果休眠1秒，会在这个时间间隙内被其中一个线程全部抢完，所以我们要使用另一个函数——usleep

该函数和sleep一样，不过是以微妙为单位，我们调整参数到毫秒级别，这样两个线程就能够交叉抢票了，如下是修改后的代码

#include<pthread.h>
#include<iostream>
#include<cstdio>
int counter = 100;
void* start_routine(void* args)
{     
    while(true){      
        if (counter > 0){          
            counter--;
            usleep(1234);
            std::cout << "抢票用户："<< (char*) args << " 剩余票数: " << counter << std::endl;                 
        }
        else break;
    }
    return nullptr;
}
int main()
{   
   pthread_t thread;
   char second_thread[] = "次线程";
   char main_thread[] = "主线程";
   pthread_create(&thread, NULL, start_routine, (void*)second_thread);
   start_routine((void*)main_thread);
   pthread_join(thread, NULL);
   return 0;
}

如下图是运行结果

根据图上信息，可以发现，两个线程确实实现了交叉抢票，但是吧，最后剩余票数出现了-1是什么情况，两个线程正常抢票，都是进行counter > 0才能进入抢票，可为什么就出现了负数了呢？接下来刨析这个问题（再次建议读者完成代码编写，亲自感受这个过程）

互斥

当票数counter只剩1的时候，此时次线程从内存中读取数据，发现counter为1，然后判断counter>0为真，但是一进入循环内，就遇到了usleep，于是次线程会被OS挂起，然后OS唤醒主线程，主线程去内存中加载counter数据时，发现counter的值仍为1，就通过了判断语句，同样的它将遇到usleep，被挂起。之后OS唤醒次线程，次线程开始执行counter-1，然后循环，判断counter为0，就退出了循环，接着主线程被OS唤醒，开始执行counter-1，注意此时的counter已经为0了，减去1之后就是-1，这也是为什么最后主线程的剩余票数会变为-1的原因

可以发现，造成这个问题的根本原因就是因为抢票过程不具备原子性，什么是原子性？当一件事具备了原子性，就说明这件事要么做成，要么失败，没有中间状态可言。回顾一下刚才抢票时，次线程检测到counter为1，它进入了循环，如果它具备原子性，那么对于抢票这件事，要么它抢票成功，counter减为0，要么它抢票失败，counter仍为1，轮到主线程抢票，在其它线程眼里这个过程是一瞬间，没任何中间过程的

但事实是它是有中间状态的，它不可能在物理上的一瞬间就抢到票把counter减为0，它是要逐步执行代码的，执行代码是需要时间的，就单单counter--这个操作，就至少得翻译成三条汇编语句逐条执行，在这段时间内，counter的值仍为1，其它线程就有机会进来了

除了上面出现负票这种情况，还有可能会导致票越抢越多的情况，只不过这种情况很难模拟出来，但它确实存在，故此我们理论上分析出现这种情况的原因

假设现在有100张票，有A，B两个进程一起抢票

这看似一个简单的counter-1操作，背后的CPU至少要分成这三部分完成，上面就是正常抢票过程中，CPU所执行的操作

如上图，因为A被挂起，长时间处于中间状态，B在这段时间内将票抢空，而A被唤醒后，继续执行中断前的操作，导致了票明明被B抢空了，却又变回99这种越抢越多的情况

面对类似抢票这种场景就得保证多个线程在执行任务时要是原子的，互斥是保证原子性的手段之一，正在抢的那个线程要么抢成功，要么抢失败，而在它抢的过程中，固有的中间状态靠互斥性来解决，也就是其他线程与当前正抢票的线程保持互斥，不能打扰它抢票

如何做到互斥？解决方法就是加锁

锁

什么是锁呢？前面提到过，抢票时我们需要对票这种共享资源进行保护，也就是抢票这个事件是要原子的，但是就单单counter--这种操作，得有三条汇编指令才能实现，这就产生了中间状态，锁就是来锁住这个中间状态，大致流程如下

当线程A正在抢票时，它需要申请一把锁，只要它申请锁成功，那么它就可以放心去执行它的抢票代码，其它的线程要想抢票也得先申请锁，但是锁已经被A拿走了，它们只能阻塞等待A释放锁才能够申请到锁

上述过程中，锁将线程A抢票的中间状态锁住了，就能够实现抢票的原子性，在其它线程看来，A抢票就是原子的，就是一瞬间，没有中间过程的。因为A拿到锁正抢票时，其它线程到了就得阻塞等待从而被OS挂起，当它们被唤醒的时候，说明A已抢完票，释放了锁，在它们眼里这可不就是一瞬间的事嘛

明白锁的作用，接下来看看怎么使用锁，锁本质也是一种数据类型，其类型为：pthread_mutex_t，使用锁之前得先申请一个锁

申请一个锁：

pthread_mutex_t  mutex;

申请完锁需要对其进行初始化，使用初始化接口：

pthread_mutex_init( pthread_mutex_t  *mutex );

第二种初始化方法：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

初始化完成之后，就可以使用锁了，使用锁分为加锁和解锁

加锁的接口为：

pthread_mutex_lock( pthread_mutex_t *mutex);

解锁的接口为：

pthread_mutex_unlock( pthread_mutex_t *mutex);

还有一个加锁的接口为：

pthread_mutex_trylock( pthread_mutex_t *mutex);

那这两个加锁接口有什么区别呢？举个例子

有线程A，B共同使用一把锁，当使用pthread_mutex_lock加锁时，A加锁完，B再来就得阻塞等待。而使用pthread_mutex_trylock加锁时，A加锁完，B再来并不会阻塞等待，而是报错返回，因此pthread_mutex_trylock也被称为非阻塞式加锁

那在哪里使用锁呢？在main函数开头就加锁，return前解锁吗？当然不是，我们要明白加锁锁的是一种中间状态，把抢票这个具有过程性的操作给保障成原子性。原本有A，B两个线程同时并行执行，但在对公共资源进行争夺时，就会带来很多的麻烦，采用加锁相当于把这些线程在抢夺资源时排好队，谁先来的谁开始，后面的排队等待，变成一种串行的执行方式

串行排队等待，程序的效率必然会下降，因此在满足公共资源保护的前提下，加锁的范围要尽量的小，接下来通过demo来演示加锁的用法，还是用上面的抢票程序

#include<pthread.h>
#include<iostream>
#include<cstdio>
#include<unistd.h>
int counter = 10;
//创建一个全局锁
pthread_mutex_t mutex;
void* start_routine(void* args)
{     
    while(true){
        //在这里加锁，保护公共资源counter
        pthread_mutex_lock(&mutex);
        if (counter > 0){          
            counter--;
            std::cout << "抢票用户："<< (char*) args << " 剩余票数: " << counter << std::endl;
            //这里counter--已经执行完毕，公共资源保护完成，可以解锁
            pthread_mutex_unlock(&mutex);
            usleep(1234);                             
        }
        else{
            //这里是程序拿到锁，然而没票了，退出之前要解锁
            pthread_mutex_unlock(&mutex);
            break;
        }   
    }
    return nullptr;
}
int main()
{   
   pthread_t thread;
   char second_thread[] = "次线程";
   char main_thread[] = "主线程";
   //初始化该全局锁
   pthread_mutex_init(&mutex, NULL);
   pthread_create(&thread, NULL, start_routine, (void*)second_thread);
   start_routine((void*)main_thread);
    pthread_join(thread, NULL);
    return 0;
}

由上面的demo可以看出，加锁和解锁的范围还是很短的，运行上面的demo，你会发现程序抢票的过程明显变慢，这是因为线程在抢票时是串行执行。该demo主要为了保护counter，counter--指令执行完，就可以解锁，避免长时间串行，影响程序效率

这里不给出代码运行结果，尝试自己编写运行

深入理解锁

上面锁的用法也看了，锁确实能保护我们的票目counter，但是你有没有想过，多个线程之间虽然老老实实排队去抢票了，但是它们会竞争锁呀，毕竟谁先拿到锁，谁就能优先执行，多个线程都在竞争同一把锁，那锁是什么？没错，锁也是一种公共资源，那么加锁的过程中是不是也有中间状态，那么谁来保护锁呢？

眼前先别黑，不需要谁来保护锁，操作系统给我们保证了加锁过程是原子性的，也就是加锁过程中不存在中间状态，用一条汇编指令就能完成

实现的方法很多，这里笔者讲一个比较通用的方法

下图是加锁的部分伪代码，也是加锁的核心

我们需要有一个场景，还是用刚才抢票的那个demo，有线程A和B同时抢票

这是锁能实现串行执行的原理，不过上述是线程A一路顺畅的拿到锁，有没有可能

线程A刚执行完movb $0, %al就被切走了呢

线程A刚执行到xchgb %al, mutex就被切走了呢

当然有可能，时间中断可能在任意一条汇编执行时就到来，加下来分别模拟一下这样的场景

上图同时包含了前面提到了两种场景，都没有什么问题，伪代码中最关键的还是xchgb指令，给交换提供了一个绝对原子的操作， 执行xchgb指令，该线程禁止被中断或受到其它线程干扰，对于解锁，要求就没那么高，下面是解锁的伪代码

封装锁

直接使用原生接口创建和调用锁，老是感觉不方便，毕竟是学C++的，就得用C++的方式给其原生接口封装一下，更符合现代编程的使用习惯，封装代码如下

#pragma once
#include<iostream>
#include<pthread.h>
#include<string>
#include<cstdio>
class thread_mutex{
public:
    thread_mutex(pthread_mutex_t * mut):_mutex_p(mut)
    {       
         *_mutex_p = PTHREAD_MUTEX_INITIALIZER;     
    }
    void lock()
    {      
        pthread_mutex_lock(_mutex_p);
    }
    void trylock()
    {
        pthread_mutex_trylock(_mutex_p);
    }
    void unlock()
    {
        pthread_mutex_unlock(_mutex_p);
    }
private:
    pthread_mutex_t* _mutex_p;
};
#include<unistd.h>
#include"C++_mutex.hpp"
int counter = 100;
pthread_mutex_t mutex;
void* start_routine(void* args)
{    
    thread_mutex _mutex(&mutex);
    while(true){
        _mutex.lock();
        if (counter > 0){          
            counter--;
            std::cout << "抢票用户："<< (char*)args << " 剩余票数: " << counter << std::endl;
            _mutex.unlock();
            usleep(1234);                            
        }
        else{
            _mutex.unlock();
            break;
        }  
    }
    return nullptr;
}
int main()
{  
   pthread_t thread;
   char second_thread[] = "次线程";
   char main_thread[] = "主线程";
   pthread_create(&thread, NULL, start_routine, (void*)second_thread);
   start_routine((void*)main_thread);
   pthread_join(thread, NULL);
   return 0;
}

如果觉得解锁用的麻烦，我们可以利用智能指针的思想，写一个析构函数，把解锁接口调用放到析构函数中，等到类的作用域结束自动解锁，这里就不演示了

小技巧：可以用{ }自定义数据类型的的作用域

死锁

锁真是个好东西啊，线程妈妈（进程）再也不怕小线程无序争夺资源，把一切都搞乱了

于是在多线程中，一旦涉及到公共资源争夺，就加一把锁，但是这么一加，就加出了问题

什么问题呢？看标题也明白了——死锁

起因是这样的，现在有公共资源A和B，公共资源A有一把锁，公共资源B也有一把锁，现在有线程1和2，线程1一开始要使用资源A，于是它把锁A给拿走了，线程2一开始要使用资源B，于是它把锁B给拿走了

线程1执行着突然发现需要资源B了，于是它等待线程2把资源B的锁还回来，不然它没法取资源B呀，可是线程2执行着发现需要资源A了，于是它等待线程1把资源A的锁还回来

线程2哪知道线程1还在等它呢？同样线程1也不知道线程2在等它呀，两个人就这样互相等啊等，没有终止，导致程序无法继续执行，这就是死锁问题

可不是只有两个及以上个锁才会造成死锁问题，一个锁也会造成死锁问题，人也会被自己绊倒，更别说一根筋的电脑了

  while(true){
拿这个例子来说，把解锁的接口全给注释了，线程A拿到锁执行完一次循环后，会再次循环，再次申请
加锁，锁本来就在它身上，加锁接口伪代码咱们也看过了，可想而知线程A也将被挂起，且锁也丢了
        _mutex.lock();
        if (counter > 0){          
            counter--;
            std::cout << "抢票用户："<< (char*)args << " 剩余票数: " << counter << std::endl;
            //_mutex.unlock();
            usleep(1234);                             
        }
        else{
            //_mutex.unlock();
            break;
        }   
    }

避免死锁的方法

出现死锁有四个必要条件

1.互斥（某线程拿到锁，那么其它线程要保持互斥，不能取该锁保护的资源)

2.请求与保持：（死锁时，各线程互相请求对方的锁，互不相让）

3.不剥夺：（各线程平等，无权强行夺取其它线程的锁）

4.环路等待条件 （出现死锁问题组成的无法打破僵局的环路）

避免死锁就是不要同时满足上面的四个必要条件，解决死锁的方法就是打破上面的条件之一

例如使用线程的优先级，死锁时优先级低的线程必须主动释放锁

相关的算法有（死锁检测算法，银行家算法等）

线程同步

什么是线程同步？线程不同步会有什么问题呢？其实咱们前面遇到过这个问题，笔者还解释了大半天，遗忘的同学前往文章开头处查看，用到的代码笔者已复制如下

当时笔者解释了半天，为什么要使用usleep()，因为线程不调度，导致票被主线程这一个线程给抢完了，或者是主线程的竞争能力太强了，它在解锁时同时也是离锁最近的，所以它一解锁，立马就循环再拿锁，次线程是一次锁都摸不到

#include<pthread.h>
#include<iostream>
#include<cstdio>
#include<unistd.h>
int counter = 10;
//创建一个全局锁
pthread_mutex_t mutex;
void* start_routine(void* args)
{     
    while(true){
        //在这里加锁，保护公共资源counter
        pthread_mutex_lock(&mutex);
        if (counter > 0){          
            counter--;
            std::cout << "抢票用户："<< (char*) args << " 剩余票数: " << counter << std::endl;
            //这里counter--已经执行完毕，公共资源保护完成，可以解锁
            pthread_mutex_unlock(&mutex);
            usleep(1234);                             
        }
        else{
            //这里是程序拿到锁，然而没票了，退出之前要解锁
            pthread_mutex_unlock(&mutex);
            break;
        }   
    }
    return nullptr;
}
int main()
{   
   pthread_t thread;
   char second_thread[] = "次线程";
   char main_thread[] = "主线程";
   //初始化该全局锁
   pthread_mutex_init(&mutex, NULL);
   pthread_create(&thread, NULL, start_routine, (void*)second_thread);
   start_routine((void*)main_thread);
    pthread_join(thread, NULL);
    return 0;
}

你说主线程违背了锁的竞争原则了吗？并没有，它是严格按照锁的竞争规则来的，但是你说这合理吗？这并不合理，主办方把票全部卖给了黄牛，即使你手速逆天，抢票时也只是卡顿一下，然后显示票已卖完

我们要避免票全让一个线程给抢完了，怎么办，简单粗暴的方法就是再加入一个排队系统，刚抢完票的线程不准再抢了，立马去排队，就能让其它的线程有机会抢到票，像这样避免一个线程独占资源而导致其它线程挨饿的就是线程同步（到这里大家应该能体会到，没写过类似的代码，看这部分内容就感觉很虚，一段时间后没有任何印象，所以请务必敲代码，亲自体验这个过程）

生产者与消费者模型

大概了解什么是同步之后，我们来了解一个线程中很重要的模型——生产者与消费者模型

故事来源于生活场景，角色有：顾客，超市，工厂

我们每个人都是顾客，又称为消费者，我们需要商品满足自身生活需求，没有什么好说的。工厂是生产商品的，又称为生产者，有需求，就有人生产嘛，同样没有什么好说的

超市这个角色值得我们聊聊，为什么要有超市呢？

如果顾客直接去工厂买东西不可以吗？顾客作为一个单独的个体，其购买的产品量是很低的，如果每个顾客都来，那每次开机就生产那么一点点东西，赚得钱可能连电费都付不起，同样的，顾客想去买东西，还得等你工厂开机生产，等到生产完，可能天都黑了

可见我们不能把顾客与工厂强关联，需要一个中间区域，在这个中间区域里，顾客随拿随走，工厂可以批量生产有存储区域

可见，超市这个东西就是把顾客和工厂解耦的，如果生产者和消费者强耦合，消费者要等待生产时间，工厂要承担零售成本，有了超市解耦，消费者随拿随走，生产者没有零售成本

大家感觉这个超市的作用熟不熟悉？ 不就是咱们前面提到过的缓冲区吗？

顾客消费可以看到超市资源，工厂供货也可以看到超市资源，那么超市不就是公共资源吗？注意指在程序里的公共资源，引入生活中的例子是便于大家理解，但不可把生活中的经验全套入到改模型里来理解该模型

下面看看消费者与生产者之间的关系

消费者与消费者之间：互斥关系

现在超市某个货品只有一个，只有一个消费者可以拿，一个拿了另一个就不能拿了，所以构成互斥关系

生产者与生产者之间：互斥关系

超市的容量是有限的，一个工厂供货了，另一个工厂就不能再供货了，故生产者与生产者之间也构成了互斥关系

生产者与消费者之间：互斥，同步

互斥还是好理解的，生产者正在给超市供货呢，还没开始统计数量呢，消费者直接就进来把商品拿走了，这样是不行的，因此消费者访问公共资源时，生产者就不能访问公共资源，反之亦然，生产者和消费者之间构成互斥关系

假设现在生产者给超市供货，而不断有消费者来购买商品，那么超市和消费者时间都浪费了，也没得到商品。同样，假设没有消费者来超市消费，而不断有生产者前来供货，那么超市和生产者时间都浪费了，也没卖出商品

为了解决这个问题，超市设置了一种同步策略，即有货的时候再通知消费者，没货时消费者不要来，同样，缺货的时候通知生产者，不缺货生产者不要来

上述生产者和消费者模型可以归纳为“321”原则

3种关系（上述的三种关系）

2个角色（生产者线程，消费者线程）

1个交易场所（一段特定结构的缓冲区，即上述超市）

现在有main函数和一个fun函数，main函数调用了fun函数，在正常情况下，main函数调用fun函数之后，fun函数开始执行，而main函数则在等待fun函数执行完毕。同样的main函数还没开始调用fun函数时，fun函数在等待main函数的调用

这里main函数和fun函数就是强耦合的关系，把这两个函数带入到生产者消费者模型

由main函数调用fun函数，所以main函数是参数的提供方（生产者），fun函数是参数的使用方（消费者）如果由两个线程来同时执行这个函数，消费者线程和生产者线程同时开始，同时设立一定的执行条件，当消费者需要数据时，而生产者还没有生产好数据，那么就挂起等待，等到生产者生产好了，满足条件了，就可以唤醒消费者，反之同理

条件变量

什么是条件变量呢？ 我们前面提到过，在生产者和消费者模型中，生产者和消费者之间要有互斥和同步的关系，互斥解决方法就是加锁嘛，条件变量就是解决同步的一种常用的方法之一，上面的模型中，超市就是公共资源，消费者消费资源，生产者生产资源，当公共资源没有了，不满足消费者的条件，那么此时消费者不能再来了，老实的挂起等待，反之同理

条件变量维护了一个不满足条件就挂起，满足条件就唤醒的队列，条件变量要和锁一起配合使用，从而满足互斥和同步的关系

所以什么是条件变量呢？其实就是在加锁后，为了维持线程同步，加了一个判断条件，满足条件的可以继续执行，不满足条件的需要挂起等待，条件变量提供了一个队列，这个队列专门用来存放这些不满足条件的线程

消费者线程去超市这个公共资源区去消费，但是此时超市已经没有货物了，所以消费者线程不满足进入超市的条件，去到条件变量里挂起等待，假设此时生产者来了，它检测到超市的货物没有满，可以供货，于是进入了超市这个公共资源区开始供货，同时供货完，它会从条件变量里唤醒一个线程，若该线程是消费者线程，此时判断超市已经有货了，于是它可以进入超市去消费资源了

条件变量的相应接口

条件变量的概念明白了，接下来就看看条件变量如何使用吧。有时你可能会看到笔者在接口和函数之间反复横跳，其实叫接口也好，叫函数也罢，两者是同一个东西，叫函数是从编程语言的角度看待，叫接口是从系统调用的角度来看待的，废话不多说，看接口

条件变量同锁一样，都是一种数据类型，里面包含了各种需要的数据结构

条件变量的数据类型为：pthread_cond_t  

声明一个条件变量： pthread_cond_t  cond;

同样，声明完要进行初始化

初始化：int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);第二个参数填NULL即可

另一种初始化方式：pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int pthread_cond_destroy(pthread_cond_t *cond);

这个比较好理解，就是把你创建的条件变量销毁

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

参数：

cond：要在这个条件变量上等待

mutex：互斥量，后面详细解释

该接口的意思是，如果判断条件不满足，那么就调用该接口，系统会把不满足条件的线程放入到条件变量的等待区中

int pthread_cond_signal(pthread_cond_t *cond);

当满足条件之后，通过调用该接口，系统会通知在条件变量里等待的线程，可以开始执行了，注意该接口只能唤醒一个线程

int pthread_cond_broadcast(pthread_cond_t *cond);

该接口和上面接口的作用是一样的，不过该接口不只是唤醒一个等待区的线程，而是唤醒一批处在等待变量中的线程

条件变量代码实操

废话不多说，直接用起来，下面是测试条件变量的demo

注：为了简便，后面称呼这些接口调用函数只用后缀代替

例如：pthread_cond_wait() 用wait简称，其它接口类似

int counter = 100;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *start_routine(void *args)
{
    thread_mutex _mutex(&mutex);
    while (true)
    {
        _mutex.lock();
        if (counter > 0)
        {
            pthread_cond_wait(&cond, &mutex);
            counter--;
            std::cout << "抢票用户：" << (char *)args << " 剩余票数: " << counter << std::endl;
            _mutex.unlock();
            // usleep(1234);
        }
        else
        {
            _mutex.unlock();
            break;
        }
    }
    return nullptr;
}
int main()
{
    pthread_t thread_1, thread_2;
    cond = PTHREAD_COND_INITIALIZER;
    char name_1[] = "抢票选手1";
    char name_2[] = "抢票选手2";
    pthread_create(&thread_1, NULL, start_routine, (void *)name_1);
    pthread_create(&thread_2, NULL, start_routine, (void *)name_2);
    while (true)
    {
        pthread_cond_signal(&cond);
        sleep(1);
    }
    pthread_join(thread_1, NULL);
    pthread_join(thread_2, NULL);
    return 0;
}

该代码用到了前面对锁的封装，主要思想就是创建两个子线程，两个子线程刚进入抢票就被wait，进入条件变量挂起等待，然后由主线程用signal逐一唤醒挂起的进程，开始抢票

理解条件变量

等等，老是觉得有些不太对劲，其一在使用条件变量的wait时，为什么要把锁传进去。其二我们不是加锁了嘛，既然加锁了就该保持互斥，也就是只有一个线程才能拿到锁，才能遇到wait，然后进入条件变量等待区，为什么上面的demo思想却说让两个子线程都进入条件变量挂起等待，等待主线程逐一将它们唤醒呢

我们的理解并没有错，只是前面没提到在wait时把锁传过去的作用，wait接口把锁传过去就是为了释放锁，因为释放了锁，其它线程才有机会进入公共资源区。假设现在有一个生产者线程和一个消费者线程，此时公共资源区已经没有资源了，所以消费者进来就得把它挂起等待，如果它把锁也带到等待区而不释放，那么生产者就进入不了公共资源区，那程序就卡死了，生产者永远进不去，消费者永远醒不来

基于BlockingQueue的生产者消费者模型

看标题是不是觉得特别深奥，但仔细看不就是基于阻塞队列的生产者消费者模型嘛，啥意思呢？就是建立一个队列，这个队列的大小是固定的，生产者不断往这个队列中写入数据，消费者不断往这个队列拿出数据，当写入速度明显大于拿出速度时，队列将被写满，就会触发条件判断，把生产者都放到条件变量等待区里。同样的，当拿出速度明显大于写入速度导致队列里没有数据了，会触发条件判断，将消费者放入条件变量的等待区里

了解功能大家可以自行实现，请务必自行实现，下面笔者给出一些参考代码

#include<iostream>
#include<pthread.h>
#include<queue>
#include<vector>
#include<ctime>
#include<cstdlib>
#include<unistd.h>
template< class T>
class thread_cond{
public:
    thread_cond()
    {
        _cond = PTHREAD_COND_INITIALIZER;
    }
    void thread_cond_push(T data, pthread_mutex_t *mutex)
    {
        if (_buffer.size() >= _capacity)
        {   
            pthread_cond_wait(&_cond, mutex);
        }
        _buffer.push(data);
        pthread_cond_signal(&_cond); 
    }
    T thread_cond_get(pthread_mutex_t *mutex)
    {
        if (_buffer.size() <= 0)
        {
            pthread_cond_wait(&_cond, mutex);
        }
        T rt_val = _buffer.front();
        _buffer.pop();
        pthread_cond_signal(&_cond);
        return rt_val; 
    }
    ~thread_cond()
    {
        pthread_cond_destroy(&_cond);
    }
private:
    std::queue<T> _buffer;
    pthread_cond_t _cond;
    size_t _capacity = 100;
};
----------------------------------------------------------------------------
pthread_mutex_t mutex;
void* start_get(void *args)
{
    thread_cond<int> * test_cond = (thread_cond<int>*)args;
    while(true)
    {
        pthread_mutex_lock(&mutex);
        int temp = test_cond->thread_cond_get(&mutex);
        std::cout << "线程："<<pthread_self() << "拿出数据" << temp <<std::endl;
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}
void* start_push(void *args)
{
    thread_cond<int> * test_cond = (thread_cond<int>*)args;
    while(true)
    {
        pthread_mutex_lock(&mutex);
        int temp = rand()%100;
        test_cond->thread_cond_push(temp, &mutex);
        std::cout << "线程："<<pthread_self() << "载入数据" << temp <<std::endl;
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}
int main()
{
    thread_cond<int> test_cond;
    pthread_mutex_init(&mutex, NULL);
    std::vector<pthread_t> threads(4);
    pthread_create(&threads[0], NULL, start_get, (void*)&test_cond);
    pthread_create(&threads[1], NULL, start_get, (void*)&test_cond);
    pthread_create(&threads[2], NULL, start_push, (void*)&test_cond);
    pthread_create(&threads[3], NULL, start_push, (void*)&test_cond);
    for (int i = 0; i < 4; i++)
    {
        pthread_join(threads[i], NULL);
    }
    return 0;
}

用模板来编写该类，主要是为了支持泛型，方便日后工作的扩展，现在我们传过去的是int类型的数据，日后可能会是一个自定义类型的类

生产者消费者模型的意义

下图是生产者，消费者模型的简述图

你会不会有这样的疑问，我们引入多线程就是为了实现程序并发，提高工作效率。但是这个生产者消费者模型，消费者想拿数据还是只能加锁一个一个的进入，同样的生产者想放入数据也是只能加锁一个一个的进入，甚至消费者和生产者之间也不能同时进入，那这并发的意义在哪里呢？既然都是一个一个的串入式进入，为何不用单线程呢？

有这样的疑惑是因为我们正在讲述生产者消费者模型，大家都把目光聚焦到这个模型中，但是这个模型仅仅是负责资源的纳入和分配，而不涉及资源的生产和处理

什么意思呢？消费者来到公共资源区是为了拿取资源，而真正消耗时间的是资源的消费过程，但是这个过程并不是在公共资源区内部进行的

同样的，生产者把生产好的数据放入公共资源区，真正消耗时间的是资源的生产过程，这个生产过程也不是在公共资源区进行的

所以多线程并发的意义并不在公共资源区中串型式的拿取增添数据，而是并行式的消费资源和生产资源，加锁是保证资源拿取和增添的安全有效，这个过程并不怎么消耗时间