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:

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

1class ProcessRequest {
2public:
3	//把命令加入到一个队列
4	void inMsgRecvQueue() {
5		
6		for (int i = 0; i < 100000; ++i) {
7			//std::lock_guard<std::mutex> sbguard(my_mutex);
8			cout << "插入一个元素" << endl;
9			m_msgRecvQueue.push_back(i); //假设这个队列表示玩家的命令
10
11		} //占用时间片
12	}
13
14	bool outMsgLULProc(int &command) {
15		//通过双重锁定，避免每次进来程序都锁定。
16		if (!m_msgRecvQueue.empty())
17		{
18			std::lock_guard<std::mutex> sbguard(my_mutex);
19
20			if (!m_msgRecvQueue.empty()) {
21				int command = m_msgRecvQueue.front();
22				m_msgRecvQueue.pop_front();
23				return true;
24			}
25			return false;
26		}
27	}
28	//把命令移出一个队列
29		void outMsgRecvQueue() {
30			int command = 0;
31			for (int i = 0; i < 100000; ++i) {
32				
33				bool result = outMsgLULProc(command);
34				if (result == true) {
35					cout << "outMsgRecvQueue() 执行，取出一个元素" << endl;
36				}
37				else
38				{
39					cout << "outMsgRecvQueue() 还执行，但是消息队列为空" << endl;
40					//消息队列为空
41				}
42				
43				//占用时间片
44			}
45		}
46	
47private:
48	std::list<int> m_msgRecvQueue; //容器，用于表示玩家的发送过来命令
49	std::mutex my_mutex;
50};

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

1pirvate:
2    std::condition_variable my_condition;

wait()

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

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

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

notify_one

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

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

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

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

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

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

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

同时获取锁的可能性：

1) void inMsgRecvQueue()

2) void outMsgRecvQueue()

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

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

深入思考

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

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

notify_all