C++并发与多线程学习笔记--线程之间调度

• condition_variable
• wait()
• notify_one
• notify_all

---

condition_variable

条件变量的实际用途：

比如有两个线程A和B，在线程A中等待一个条件满足，(消息队列中有要处理的消息)，线程B专门往队列中丢数据。当B往线程中放入数据，同时B通知线程A，开始往下执行。在服务器的后台设计中，有一个线程，阻塞式地读取消息，并且将其解析，放入队列中，此时线程B还通知A，要从队列中去拿请求，并进行处理。

 

a) socket技术使得服务器中的程序能够像打开文件一样来读取数据。

b) 线程B读取数据，并将其放入到消息队列中。

c) 线程B唤醒线程A，让线程A从队列中拿数据。

d) 服务器处理请求完成并返回结果。

通过条件变量类可以使得A等待B:

复习原先的代码：(通过双重锁定，使得每次都判断是否为空，如果为空那么就取得锁)

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

class ProcessRequest { public:     //把命令加入到一个队列     void inMsgRecvQueue() {                   for (int i = 0; i < 100000; ++i) {             //std::lock_guard<std::mutex> sbguard(my_mutex);             cout << "插入一个元素" << endl;             m_msgRecvQueue.push_back(i); //假设这个队列表示玩家的命令           } //占用时间片     }       bool outMsgLULProc(int &command) {         //通过双重锁定，避免每次进来程序都锁定。         if (!m_msgRecvQueue.empty())         {             std::lock_guard<std::mutex> sbguard(my_mutex);               if (!m_msgRecvQueue.empty()) {                 int command = m_msgRecvQueue.front();                 m_msgRecvQueue.pop_front();                 return true;             }             return false;         }     }     //把命令移出一个队列         void outMsgRecvQueue() {             int command = 0;             for (int i = 0; i < 100000; ++i) {                                   bool result = outMsgLULProc(command);                 if (result == true) {                     cout << "outMsgRecvQueue() 执行，取出一个元素" << endl;                 }                 else                 {                     cout << "outMsgRecvQueue() 还执行，但是消息队列为空" << endl;                     //消息队列为空                 }                                   //占用时间片             }         }       private:     std::list<int> m_msgRecvQueue; //容器，用于表示玩家的发送过来命令     std::mutex my_mutex; };

　　使用类std::condition_variable来替代双重锁定，用来等待一个条件达成，这个类需要和互斥量配合工作，用的时候需要生成类的对象。

?

1 2	pirvate:     std::condition_variable my_condition;

　　

wait()

出队列修改： wait是卡在这里的，需要修改入队列的线程。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

void outMsgRecvQueue() {     int command = 0;     while (true) {         std::unique_lock<std::mutex> sbguard1(my_mutex);         my_condition.wait(sbguard1, [this] {             if (!m_msgRecvQueue.empty())//lambda表达式就是一个可调用对象(函数)                 return true;             else                 return false;         }); //wait用来等待一个东西     //Wait(para1, para2)     //para1: 互斥量     //para2:第二个参数Lambda表达式的返回值是False     //      那么将解锁互斥量,并阻塞本行，直到其他线程调用 notify_one()     //如果没有第二个参数,那么就跟第二个参数返回False效果一样     } }

　　当然wait()之后可以提早解开 unique_lock()，然后执行逻辑。

 

notify_one

将原来阻塞的进程唤醒了。wait就开始恢复干活了，恢复之后

a) wait() 不断尝试获取互斥量锁，尝试拿这个锁。如果获取不到锁，流程就卡在wait这里,如果获取到，wait就走下来了。

b) 实际上获取到了锁就等于上了锁。如果wait有第二个参数(lambda)，就判断lambda表达式，

     如果表达式为false，又将互斥量解锁。然后另一个线程又休眠。

     如果表达式为true,则wait返回，流程走下来(此时互斥锁被锁着)。

     如果wait没有第二个参数，则wait返回

?

1 2 3 4 5 6 7 8 9

void inMsgRecvQueue() {           for (int i = 0; i < 100; ++i) {         std::lock_guard<std::mutex> sbguard(my_mutex);         m_msgRecvQueue.push_back(i); //假设这个队列表示玩家的命令         cout << "插入一个元素" << endl;         my_condition.notify_one();     } //占用时间片 }

　

同时获取锁的可能性：

1) void inMsgRecvQueue()

2) void outMsgRecvQueue()

可能出现同时竞争一个锁的可能性，也就是说如果运行到了outMsgRecvQueue()的逻辑执行语句的时候，队列中至少进去了一个元素，那么就有可能出现in和out并不是按序执行的情况。

　out在执行逻辑语句的时候有延迟，此时如果in唤醒，out并不是卡在wait()的状态，那么此时notify_one()调用就没有效果。

 

深入思考

写代码用在商业中，必须理解。

在线程入口函数中， 队列中可能会存在多条数据，这个时候处理不过来怎么办？开更多的线程处理？或者限流，超过200条数据未处理，就卡住？

notify_all