生产者和消费者模型
基于阻塞队列实现cp模型
引言
在上一节，我们了解了有关线程同步的知识
所谓的线程同步，是解决死锁问题的其中一种方法
在安全的规则下，多线程按照一定顺序的访问资源，进行协同工作，我们称之为线程同步
基于互斥和同步的概念，我们可以提出不同的模型
今天要介绍的就是生产者和消费者模型
并且我们基于BlockQueue(阻塞队列)来尝试实现它
回归生活
生产者和消费者模型，这个名字我们一听，可能会觉得非常高大上
但是实际上，在生活中我们处处可见
建立在这模型之上，最常见的例子，就是我们的超市
供应商(生产者)生产我们的商品，将其运往我们的超市
顾客(消费者)从超市中购买自己需要的商品
但是我们是否想过，为什么生活中需要存在超市呢？
顾客可以直接去对应的供应商买相应的商品不就行了吗？这样价格反而会更加便宜
原因主要有两个
第一，无论供应商做什么，它的最终目的都是赚钱，以利益作为一切的根本，损害利益的事情，商人是不会做的
谈到利益，成本往往是无法躲开的一个话题，供应商每次生产产品，可能就要开动数台机器，而这些都是需要耗费成本的
但是顾客的需求是零散的，供应商是不可能为了你一个顾客要买一包零食，整个工厂哗哗的运行起来
而超市作为交易场所，则能够充当一定缓冲的作用(缓存)
供应商只管生产商品，而不再需要考虑顾客需求零散的问题，更进一步来说，超市还能够根据食品的销量，反馈给供应商，使其调整对应产品的生产
第二，我们在超市中所买的食物等等，看一下保质期，其实大多都不是当天生产出来，然后运往到我们的超市里
也就是说，超市的存在，允许生产消费的步调可以不一致，达到某种解耦合的作用
假如我们把超市对应于我们的的缓冲区，一种数据结构，它可以是队列，也可以是栈等等
把消费者和生产者对应于我们的线程
把商品对应于我们的“数据”
这就是我们的消费者和生产者模型
进一步探讨
但是，在我们上面生活的小例子中，其实蕴含了一个大前提
超市，是需要被顾客和供应商同时看到的
换句话说，假如顾客不知道这个超市的存在，从来没在这买过商品；或者说超市联系不上对应的供应商，没有对应的商品销售
就根本谈不上算我们的消费者和生产者模型
同理：交易场所必须先被所有线程所看到！
说起这句话，其实我们很熟悉，因为我们之前所了解过的管道，其实就是这个模型的一个实例
而既然，交易场所，会被所有线程所看到
这就注定了，交易场所一定是一个会被多线程并发访问的公共资源！
也就注定了，在这种模型下，我们要维护线程互斥与同步的关系
如何进行维护呢？
想要谈如何进行维护，不如先问，我们需要维护什么？
是维护不同线程吗？
答案是维护不同线程之间的关系！互斥与同步是线程与线程之间的关系
在生产模型中，一共有三种关系
第一，生产者和生产者
第二，生产者和消费者
第三，消费者和消费者
我们先来看第一种，生产者和生产者之间是什么关系呢？
答案是互斥，超市的空间资源是有限的，不同供应商肯定都希望自己的商品尽可能占据更多更优的位置，两者之间是互相竞争的
再来看第二种，生产者和消费者之间又是什么关系呢？
当供应商没有运送商品到超市的时候，消费者能够进行消费吗？
或者说，一个超市没有顾客来，供应商还会不断生产商品运往该超市吗？
因此，无论是作为生产者线程，或者是消费者线程，都不可能频繁访问超市中的资源，必须按照一定顺序，供应商生产后，消费者进行消费
因此两者是同步(互相协同)的关系
最后是第三种，消费者和消费者之间又是什么关系呢？
举个极端点的例子，超市只剩下最后一包薯片，你和另外一个人，同时都想吃薯片，此时两人可能就会进行竞争，看谁更快拿到薯片
因此两者是互斥的关系
总结
所以，如何实现生产者和消费者模型呢？
本质就是用代码来实现，我们所说的321原则
3：三种关系
2：消费者和生产者
1：1个交易场所，通常是缓冲区
代码实现
成员变量
说了这么多，没有代码实现，都是纸上谈兵
首先着手实现我们的阻塞队列
第一步，思考类中包含的私有成员有什么？
queue队列肯定不能少
由于queue队列是公共的资源，所有线程都能看到
因此，一把公共锁(互斥量)也是必不可少的
同样的，我们前面提到过消费者和生产者之间的关系是同步，所以我们还需要条件变量作为我们的成员变量
并且由于同时存在消费者和生产者，所以我们需要两个条件变量，也就是有两个不同的队列，维护等待关系
最后为了实现方法的方便，我们还补充一个_cap，用来记录队列能够存储多少元素
构造与析构
构造函数就没有什么要说的，初始化时，用户只需要传入队列的容量即可
然后在构造和析构中，前者我们需要初始化锁，条件变量
后者我们需要销毁锁，条件变量
pop，push
push相应元素进队列(入列)
必定需要先检查队列是否为满，假如队列已经满了，是无法进行入列这个操作的
因此，为了使代码更为清晰，我们可以先在类内部实现isFull方法，用来判断队列是否为满
push之前，先进行加锁操作，保证不会出现多线程访问临界资源，而导致并发问题出现
假如队列满了，那该线程就要条件变量进行等待
还有两点需要注意！
第一.所谓的等待，本质来说就是线程切换
也就意味着，当线程被重新唤醒的时候，注定了会从临界区内部继续向后执行，因为线程是在临界区被切走的
但是在条件变量等待时，锁已经被释放了，后续甚至还有解锁的操作
因此，被重新唤醒时，该线程还需要重新申请锁，申请成功后，才会彻底返回
第二.当执行完往队列里面放元素的操作后，此时队列一定不为空
因此，我们要及时唤醒消费者过来消费 这个操作放到解锁之前或者解锁后，没有差别.
实现完push操作，pop操作也是类似的
当然，push的时候，由于入队列的数据并不会被修改，因此直接传引入作为参数即可
但是pop操作需要获取出列的元素，所以应该传相应的指针进来
同样的，当队列为空时，是无法进行出列操作的
因此，我们还是先实现isEmpty函数，用来判断队列是否为空
整体代码展示
1 #pragma once
2 #include <iostream>
3 #include <pthread.h>
4 #include <queue>
5
6 const int gcap = 5;
7 template <class T>
8 class blockQueue
9 {
10 public:
11 blockQueue(const int cap = gcap):_cap(cap)
12 {
13 pthread_mutex_init(&_mutex,nullptr);
14 pthread_cond_init(&_consumerQueue,nullptr);
15 pthread_cond_init(&_productorQueue,nullptr);
16 }
17 ~blockQueue()
18 {
19 pthread_mutex_destroy(&_mutex);
20 pthread_cond_destroy(&_consumerQueue);
21 pthread_cond_destroy(&_productorQueue);
22 }
23 //判断队列是否为空
24 bool isEmpty() { return _q.empty(); }
25 //判断队列是否为满
26 bool isFull() { return _q.size() == _cap; }
27 void push(const T& data)
28 {
29 //加锁
30 pthread_mutex_lock(&_mutex);
31 //判断是否为满
32 while(isFull())
33 {
34 //假如为满的，则进入对应的等待队列里面，不要再继续生产了
35 pthread_cond_wait(&_productorQueue,&_mutex);
36 }
37 _q.push(data);
38 //往里面push数据了，这就说明肯定有商品了，可以唤醒消费者来进行消费
39 pthread_cond_signal(&_consumerQueue);
40 //解锁
41 pthread_mutex_unlock(&_mutex);
42 }
43 void pop(T* data)
44 {
45 //加锁
46 pthread_mutex_lock(&_mutex);
47 //判断是否为空
48 while(isEmpty())
49 {
50 pthread_cond_wait(&_consumerQueue,&_mutex);
51 }
52 //先通过指针获取出列数据
53 *data = _q.front();
54 //出列
55 _q.pop();
56 //往里面pop数据了，说明队列此时不为空，可以唤醒生产者来继续生产
57 pthread_cond_signal(&_productorQueue);
58 //解锁
59 pthread_mutex_unlock(&_mutex);
60 }
61 private:
62 std::queue<T> _q; //队列
63 int _cap; //容量
64 pthread_mutex_t _mutex; //锁
65 pthread_cond_t _consumerQueue; //消费者条件变量
66 pthread_cond_t _productorQueue; //生产者条件变量
67 };
结果展示
主函数构建两个线程，一个往队列存数据，另外一个往队列取数据，一直循环进行
1 #include "blockQueue.hpp"
2 #include <iostream>
3 #include <unistd.h>
4 #include <pthread.h>
5 #include <ctime>
6
7 using namespace std;
8 void* consumer(void* args)
9 {
10 blockQueue<int>* bq = static_cast<blockQueue<int>*>(args);
11 //一直往里面取数据
12 while(true)
13 {
14 int data;
15 bq->pop(&data);
16 cout << "consumer data: " << data << endl;
17 }
18 }
19 void* productor(void* args)
20 {
21 blockQueue<int>* bq = static_cast<blockQueue<int>*>(args);
22 while(true)
23 {
24 sleep(1);
25 int data = rand()%30 + 1;
26 bq->push(data);
27 cout << "productor data: " << data << endl;
28 }
29 }
30 int main()
31 {
32 srand((uint64_t)time(nullptr) ^ getpid());
33 blockQueue<int>* bq = new blockQueue<int>();
34 pthread_t c,p; //创建两个线程
35 pthread_create(&c,nullptr,consumer,(void*)bq);
36 pthread_create(&p,nullptr,productor,(void*)bq);
37
38 pthread_join(c,nullptr);
39 pthread_join(p,nullptr);
40
41 return 0;
42 }
从结果也可以看出，存取数据的快慢，取决于生产者和消费者之间较慢的那一个，假如我们让消费者先sleep1秒，则生产者在迅速产生出5个随机数，放入队列后，就会被阻塞
细节剖析
细节1
为什么采用while，而不是采用if？
1.1 pthread_cond_wait函数是让当前执行流进行等待的函数，是函数就意味着有可能调用失败，调用失败后该执行流就会继续往后执行。
1.2 其次，我们现在只是单生产者单消费者，假如是多生产者多消费者，情况又将不一样，举一个极端例子，假如队列此时为空，则多个消费者线程都会进入条件变量中等待，如果此时有一个生产者，生产了一个数据，然后将全部消费者唤醒，此时其中一个消费者就会立马出列，而队列又会陷入空的情况，此时其它消费者线程就会陷入伪等待的状态，队列里面为空，但还是要执行出列操作，因此程序就会崩溃
所以，为了保证在任何时候，都要符合条件，才进行生产，我们将if修改为while
细节2
如何理解高效呢？
理解这个问题的关键，在于正确认识生产和消费
假如单纯取数据，读数据，是没有任何高效可言的，反而因为加锁的缘故，由原来的并发执行转为串行执行，使效率降低
但是高效率针对的是获取数据的过程和数据处理的部分！
我们拿到数据后，还需要对数据进行处理，那其它消费者线程依旧是并行执行的，它们依旧可以继续处理数据，彼此间互不干扰
同理，获取数据也是如此，有生产者线程往队列里面存数据，并不影响其它生产者线程继续获取数据
这就是我们前面提到的缓存
同样，消费者线程不需要等待生产者线程什么时候往队列里面存数据，彼此之间互不干扰，生产与消费独立开来
这就是我们前面提到的解耦
细节3
不要认为队列里面只能放数据
还可以放对象！这些对象可以是一个个的任务，分发给多消费者进行执行
我们可以对代码进行简单的修改实现上面的说法
实现一个Task类，里面就包含各种运算符实现的操作
入队列时，传入一个Task类的实例对象
出队列时，调用对象里面的方法，进行计算，返回相应的结果
1 #pragma once
2 #include <iostream>
3 #include <string>
4
5 class Task
6 {
7 public:
8 //无参构造
9 Task()
10 {}
11 Task(int x,int y,char op):_x(x),_y(y),_op(op),_result(0),_exitflag(0)
12 {}
13 ~Task()
14 {}
15 void operator()()
16 {
17 switch(_op)
18 {
19 case '+':
20 {
21 _result = _x + _y;
22 break;
23 }
24 case '-':
25 {
26 _result = _x - _y;
27 break;
28 }
29 case '*':
30 {
31 _result = _x * _y;
32 break;
33 }
34 case '/':
35 {
36 if(_y == 0)
37 _exitflag = -1;
38 else
39 _result = _x / _y;
40 break;
41 }
42 case '%':
43 {
44 if (_y == 0)
45 _exitflag = -2;
46 else
47 _result = _x % _y;
48 break;
49 }
50 default:
51 break;
52 }
53 }
54 std::string formatArgs()
55 {
56 return std::to_string(_x) + _op + std::to_string(_y) + "=";
57 }
58 std::string formatRes()
59 {
60 return std::to_string(_result) + "(" + std::to_string(_exitflag) + ")";
61 }
62 private:
63 int _x;
64 int _y;
65
66 char _op; //运算符
67 int _result; //运算的结果
68 int _exitflag; //退出成功与否
69 };
修改后的主函数代码
1 #include "blockQueue.hpp"
2 #include "Task.hpp"
3 #include <iostream>
4 #include <unistd.h>
5 #include <pthread.h>
6 #include <ctime>
7
8 using namespace std;
9 void* consumer(void* args)
10 {
11 blockQueue<Task>* bq = static_cast<blockQueue<Task>*>(args);
12 //一直往里面取数据
13 while(true)
14 {
15 Task t;
16 bq->pop(&t);
17
18 t();
19 cout << "consumer task: " << t.formatArgs() << t.formatRes() << endl;
20 }
21 }
22 void* productor(void* args)
23 {
24 sleep(1);
25 blockQueue<Task>* bq = static_cast<blockQueue<Task>*>(args);
26 std::string opers = "+-*/%";
27 while(true)
28 {
29 int x = rand()%30 + 1;
30 int y = rand()%20 + 1;
31 char op = opers[rand()%(opers.size())];
32
33 //创建任务
34 Task t(x,y,op);
35 bq->push(t);
36 cout << "productor task: " << t.formatArgs() << "?" << endl;
37 }
38 }
39 int main()
40 {
41 srand((uint64_t)time(nullptr) ^ getpid());
42 blockQueue<int>* bq = new blockQueue<int>();
43 pthread_t c1,c2,p1,p2; //创建多个线程
44 pthread_create(&c1,nullptr,consumer,(void*)bq);
45 pthread_create(&c2,nullptr,consumer,(void*)bq);
46
47 pthread_create(&p1,nullptr,productor,(void*)bq);
48 pthread_create(&p2,nullptr,productor,(void*)bq);
49 //pthread_create(&p3,nullptr,productor,(void*)bq);
50
51 pthread_join(c1,nullptr);
52 pthread_join(c2,nullptr);
53 pthread_join(p1,nullptr);
54 pthread_join(p2,nullptr);
55 //pthread_join(p3,nullptr);
56 delete bq;
57 return 0;
58 }
细节4
为什么我们这份代码，只用一把锁呢？
根本原因在于我们生产和消费的是同一个队列Queue，并且Queue被当作整体进行使用
该阻塞队列是共同的临界资源，一个临界资源，防止出现并发问题，必须遵守同样的规则，也就是共用同一把锁
基于循环队列实现cp模型
信号量
引言
平时看电影之前，我们都需要买票
买票的本质是什么呢？
1.对座位资源的预定机制
2.确保不会因为多放出去特定的座位资源，而导致资源不足的情况
假如你买了票，那这个座位，就是你的！即便你临时有事，没有去看电影，那这个座位在这个时段的所有权依旧归你所有
同时，你能够买票成功，也就意味着这份资源是存在的,并不会存在没有座位，但电影院仍然卖票给你的情况
信号量，就和我们的电影票类似，它的本质是一个计数器
通过对资源的预定，从而实现线程同步协作，解决我们的死锁问题
那什么叫做对资源的预定呢？
其实就是对计数器进行pv操作(加减操作)
其中p和–相等，v和++相等，两个的操作都是原子性的！
和我们之前编写阻塞队列，从而实现cp模型不同，现在我们不把队列看作一个整体进行操作(之前需要把队列看作一个整体，进行判空，判满的操作)
现在我们把队列看作一个个小的资源组合体
每一个线程，在访问对应资源的时候，先申请信号量，申请成功，则表示该线程允许使用该资源；申请失败，则意味着资源不足！
就和我们买电影票一样，一旦电影票买到手了，这个座位也就被提前预定归属于我，任何人都无法抢走；假如没买到，就意味着你想买的座位已经属于别人了！
这样做的一个直接好处是
我们之前提到过，在临界区前加锁后，我们需要判断资源，如果该资源不存在，就进入对应的条件变量进行等待，来实现我们的线程同步
但是现在我们可以把判断转化成为对信号量的申请，而不再需要在临界区中进行判断，只要信号量不为0，则表示资源可用，表示线程可以访问
可以在申请锁之前，申请对应信号量，以此实现线程同步的功能
认识接口
信号量的接口都非常简单明了
sem_init()
通过该接口，我们可以实现对一个信号量的初始化，其中pshread我们经常设为0，初始值我们按照具体需求进行指定
sem_destroy()
通过该接口，我们可以将一个信号量进行销毁，和指针类似，申请使用完后，记得及时销毁
sem_wait()
通过该接口，我们可以实现P操作，即对信号量进行-1操作
sem_post()
通过该接口，我们可以实现V操作，即对信号量进行+1操作
代码实现
思考的问题
与之前阻塞队列不同，现在我们采取的循环队列容器，会被肢解为一个个小的资源，然后供不同的线程进行预定
但是生产者和消费者锁关注的资源是相同的吗？
答案是不一样
对于生产者来说，它关注的应该是队列是否还有空间剩余，假如空间满了，它继续生产也没有任何意义
而对于消费者来说，它关注的则是数据，假如没有数据可以从队列中取出，则消费者不可能继续进行消费
因此，从我们上述的说法中也可以看出
只要消费者和生产者访问不同的区域，生产和消费行为是可以同步进行的！
因为两者想要的东西并不相同
生产者只管生产，消费者只管消费即可，你放我拿，这就是我们前面所说的解耦
但是假如访问相同的区域呢？此时就意味着队列已经为满或者为空
队列为满，意味空间资源耗尽，则必须让消费者先进行消费，带来新的空间资源
队列为空，意味数据资源耗尽，则必须让生产者先进行生产，带来新的数据资源
因此，我们在设计信号量的时候，必须存在两个信号量
一个是数据信号量sem_data,另一个是空间信号量sem_room
当消费者对数据信号量进行p操作时，同时要对空间信号量进行v操作
当生产者对空间信号量进行p操作时，同时要对数据信号量进行v操作
保持申请自己的资源，互相v对方的资源的原则
当队列为空的时候，消费者线程是不可能会运行的，因为无法申请到数据信号量，必须要生产者先生产后，对数据信号量进行v操作，消费者线程才会运行
同理，队列为满的时候，生产者线程是不可能会运行的，因为无法申请到空间信号量，必须要消费者先消费后，对空间信号量进行v操作，生产者线程才会运行
成员变量
同样，没有代码实现，都是纸上谈兵
我们开始着手实现我们的循环队列
第一步依旧是思考类中包含的私有成员有什么？
循环队列ring肯定不能少，这里我们采用经典的实现方法，也就是ring实际上是一个vector
想要实现循环队列，头指针front和尾指针rear也是必不可少的，当然，两个指针还有另外一个作用，就是告诉对应的线程访问队列中的哪一部分资源，从而真正实现我们把循环队列拆分成一个个小资源的说法
然后是我们之前提到过的两个信号量，用来维护我们生产者和消费者之间的同步关系
但是，这样就够了吗？
答案肯定是不行！生产者和生产者，消费者和消费者的互斥关系，我们还没有进行维护
也就是锁肯定也是必须的！
要几把呢？
之前由于我们把队列看作一个整体进行操作，访问的是同一个临界资源，因此，只需要一把锁就足够
但是现在关注的临界资源数可不止一个，有两个，分别是数据和空间
因此我们需要两把锁，来维护互斥关系
当一个消费者线程取数据的时候，其它消费者线程不要也一起取数据；同理，当一个生产者线程存数据的时候，其它生产者线程不要也一起存数据，这都会导致并发问题的出现
可以看见，代码的实现，本质还是维护我们三个线程关系
构造析构
由于有两把锁，两个信号量
所以分别要调用相应的接口进行初始化
同样的，我们规定刚开始生产的时候，消费者和生产者的位置下标都从0开始
为了使代码看上去更为简便，我们可以稍微对原来的接口函数进行封装
设定队列初始容量为5
pop,push
思路：
申请资源----加锁----pop,push操作-----解锁-----给对方资源加1的思路即可完成push,pop的代码
整体代码展示
1 #pragma once
2
3 #include <iostream>
4 #include <pthread.h>
5 #include <semaphore.h>
6 #include <vector>
7
8 static const int N = 5;
9 template <class T>
10 class RingQueue
11 {
12 public:
13 void P(sem_t&m)
14 {
15 sem_wait(&m);
16 }
17 void V(sem_t&m)
18 {
19 sem_post(&m);
20 }
21 void Lock(pthread_mutex_t& l)
22 {
23 pthread_mutex_lock(&l);
24 }
25 void Unlock(pthread_mutex_t& l)
26 {
27 pthread_mutex_unlock(&l);
28 }
29 public:
30 RingQueue(int num = N):_ring(num),_cap(5)
31 {
32 sem_init(&_data_sem,0,0); //数据信号量初值为0
33 sem_init(&_room_sem,0,num); //空间信号量初值为num
34 _c_step = _p_step = 0;
35 pthread_mutex_init(&_c_mutex,nullptr);
36 pthread_mutex_init(&_p_mutex,nullptr);
37 }
38 ~RingQueue()
39 {
40 sem_destroy(&_data_sem);
41 sem_destroy(&_room_sem);
42 pthread_mutex_destroy(&_c_mutex);
43 pthread_mutex_destroy(&_p_mutex);
44 }
45
46 //生产
47 void push(const T&in)
48 {
49 P(_room_sem); //申请空间信号量
50 Lock(_p_mutex); //加锁，实现多生产者互斥关系
51 _ring[_p_step++] = in;
52 _p_step %= _cap; //判断是否越界，及时返回
53 Unlock(_p_mutex);
54 V(_data_sem); //数据信号量加1
55 }
56 //消费
57 void pop(T *out)
58 {
59 P(_data_sem); //申请数据信号量
60 Lock(_c_mutex);
61 *out = _ring[_c_step++];
62 _c_step %= _cap;
63 Unlock(_c_mutex);
64 V(_room_sem); //空间信号量加1
65 }
66 private:
67 std::vector<T> _ring; //循环队列
68 int _cap; //队列容量
69 int _c_step; //消费者生产的位置
70 int _p_step; //生产者消费的位置
71 sem_t _data_sem; //数据资源，只有消费者关心
72 sem_t _room_sem; //空间资源，只有生产者关心
73
74 pthread_mutex_t _c_mutex; //消费者锁
75 pthread_mutex_t _p_mutex; //生产者锁
76 };
结果展示
1 #include "RingQueue.hpp"
2 #include <pthread.h>
3 #include "Task.hpp"
4 #include <unistd.h>
5 #include <cstring>
6
7
8 using namespace std;
9
10 const char* opers = "+-/*%";
11 void* ConsumerRoutine(void* args)
12 {
13 RingQueue<Task> *rq = static_cast<RingQueue<Task>*>(args);
14 while(true)
15 {
16 Task t;
17 rq->pop(&t);
18 t();
19 cout << "Answer: " << t.formatRes()<< endl;
20 }
21 }
22 void* ProductorRoutine(void* args)
23 {
24 RingQueue<Task> *rq = static_cast<RingQueue<Task>*>(args);
25 while(true)
26 {
27 int x = rand()%100;
28 int y = rand()%100;
29 char op = opers[(x + y) % strlen(opers)];
30 Task t(x,y,op);
31 rq->push(t);
32 cout << "productor task: " << t.formatArgs() << "?" << endl;
33 }
34 }
35 int main()
36 {
37 srand((uint64_t)time(nullptr) ^ getpid());
38
39 RingQueue<Task> *rq = new RingQueue<Task>();
40 pthread_t c[3],p[2];
41 for (int i = 0;i < 3;i++)
42 {
43 pthread_create(c + i,nullptr,ConsumerRoutine,rq);
44 }
45 for (int i = 0;i < 2;i++)
46 {
47 pthread_create(c + i,nullptr,ProductorRoutine,rq);
48 }
49
50 //线程等待
51 for(int i = 0;i < 3;i++)
52 {
53 pthread_join(c[i],nullptr);
54 }
55 for(int i = 0;i < 2;i++)
56 {
57 pthread_join(p[i],nullptr);
58 }
59
60 delete rq;
61 return 0;
62 }
细节剖析
细节1
信号量在前，先申请信号量，再申请锁比较推荐
由于持有锁后，后面线程就无法继续执行临界区里面的代码了，所以假如信号量放在临界区里，则其它线程无法提前申请信号量
就像座位安排，每次只有一个人能够进教室，然后找到一个位置坐下
信号量就是我们的座位资源
虽然每一次只能有一个人能够进入教室，但是座位是可以提前被安排(预定)的！
这样进教室就不用找座位，而是直接到对应位置坐下即可，更为高效
细节2
同样的，cp模型的意义绝对不在于从缓冲区中放入和拿出数据，而是获取和处理数据的部分！
两种实现方法对比总结
信号量与条件变量最大一点的不同
就在于信号量不需要在临界区内部进行判断，它是一个计数器，通过信号量的剩余多少，我们就可以知道临界资源的使用情况
但是条件变量不同，我们需要在临界区内部对资源多少进行判断，假如不存在相应的资源，我们需要及时把对应的线程挂起，避免死锁情况，等有相应的资源，才会重新被唤醒
因此，什么时候使用条件变量，什么时候使用信号量呢？
关键就在于对应的临界资源，你把它看作是一个整体，还是切分成一个个小资源集合
假如是前者，那你只需要一把锁，维护互斥关系，还有两个条件变量，维护同步关系
假如是后者，那则需要两把锁，维护互斥关系，还有两个信号量，维护同步关系
2257
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
