C++ 多线程学习(3) ---- 条件变量

1. 条件变量简介 

在 C++ 11中，我们可以使用条件变量（condition variable）实现多个线程之间的同步操作，当条件不满足时，相关线程一直被阻塞，直到某种条件成立，这些线程才会被唤醒。

条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包含两个动作：

• 一个线程因为等待条件变量的条件成立而挂起，
• 另外一个线程使条件成立，给出信号，从而唤醒被等待的线程。

为了防止竞争，条件变量总是和一个互斥锁结合在一起，通常情况下这个锁是 std::mutex，并且管理这个锁的只能是 std::unique_lock<std::mutex> RAII 的模板类。

原子操作的概念：

所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。

临界资源：

临界资源是一次执行过程仅仅允许一个进程使用的共享资源，各个进程采取互斥的方式实现共享，属于临界资源的硬件有 打印机，磁带机等，软件有消息队列，变量，数组，缓冲区等，各个进程采取互斥的方式实现对这种资源的共享。（可以理解为对资源的一次操作不能被打断，也就是一次操作过程需要完整，不能操作出现中间切走的情况）

临界区：

每个进程访问临界资源的那段代码称为临界区（criticalsection），每次只允许一个进程进去临界区，进去后，不允许其他进程进入。不论是硬件临界资源还是软件临界资源，多个进程必须互斥的对它进行访问，使用临界区时，一般不允许其运行时间过长，只要运行在临界区的线程还没有离开，其他所有进入此临界区的线程都会被挂起而进入等待状态，并在一定程度上影响程序的运行性能。

2. 条件变量的使用接口

上面提到的两个步骤，分别用下面的方法实现：

等待条件成立使用的是 condition_variable 类成员函数 wait，wait_for 和 wait_unitl，

给出信号的使用的是 condition_variable 类成员函数 notify_one 和 notify_all 函数

2.1 wait/wait_for 函数

wait 导致当前线程阻塞直至条件变量被通知，或虚假唤醒发生，可选地循环直至满足某谓词。

wait_for 函数导致当前的线程阻塞直到条件变量被通知，或者虚假唤醒发生，或者超时返回。

返回值说明：

1. 如果经过 rel_time 指定的关联时限则为 std:cv_status:timeout，否则为 std:cv_status:no_timeout

以上两个类型的 wait 函数都会在阻塞的时候，自动释放锁的权限，即调用 unique_lock 的成员函数 unlock()，以便于其他线程能够有机会获得锁，这就是条件变量只能和 unique_lock 一起使用的原因，否则线程一直占有锁，线程被阻塞。

2.2 notify/notify_one

notify/notify_one 函数声明如下：

notify_one：任何线程在 *this 上等待，则调用 notify_one 会解阻塞（唤醒）等待的线程之一

notify：唤醒任何在 *this 上等待的线程

在正常的情况下，wait 类型函数返回时要不是因为被唤醒，要不是因为超时才返回，但是在实际中发现，因为操作系统的原因，wait 类型在不满足条件时，它也会返回，这就导致了虚假唤醒，因此我们一般都是使用带有谓词参数的 wait 函数。

condition_variable 的一般用法如下：

• 如果两个线程共享的变量存在其中一个线程读取，另一个线程写入的情况，或者存在两个线程都要写的情况，那么它们共享的变量需要在互斥锁的保护之下。
• notify 函数本身也需要在互斥锁的保护之下
• wait 函数本身就带有一个互斥锁的参数

condition_variable threadqueueDemo::cv;
mutex threadqueueDemo::mDisplayMutex;
queue<int> threadqueueDemo::mDisplayQueue;

void threadqueueDemo::threadLoop() {
	    while (true) {
		{
		    unique_lock<mutex> lock(mDisplayMutex);
			if (mDisplayQueue.empty()) {
				cout << "thread tid = " << this_thread::get_id() << endl;
				cv.wait(lock);
			} else {
				auto p = mDisplayQueue.front();
				mDisplayQueue.pop();
				cout << "get data p =" << p << endl;
			}
		}
	}
}

threadqueueDemo::threadqueueDemo() {
	t = new thread(threadLoop);
	t->detach();

	for (int i = 0; i < 20; i++) {
		pushdata();
		this_thread::sleep_for(chrono::milliseconds(500ms));
	}
}

void threadqueueDemo::pushdata() {
	unique_lock<mutex> lock(mDisplayMutex);
	{
		++mData;
		mDisplayQueue.push(mData);
    	cv.notify_all();
	}
}


void threadqueueDemo::testthreadqueue(int argc, char* argv[]) {
	threadqueueDemo* t = new threadqueueDemo;
}

3. 生产者消费问题

在这里，我们使用条件变量，解决生产者-消费者问题，该问题的主要描述如下：

生产者-消费这个问题，也称为有限缓冲问题，是一个进程/线程同步问题的经典案例。该问题描述了共享固定大小缓冲区的两个进程/线程—— 就是所谓的生产者和消费者，在实际运行时会发生的问题。

生产者的主要作用是生成一定量的数据放到缓冲区，然后重复此过程。与此同时，消费者也在缓冲区中消耗这些数据。该问题的关键就是要保证生产者不会再缓冲区满时加入数据，消费者也不会在缓冲区空时消耗数据。

要解决该问题，就必须让生产者在缓冲区满时休眠，等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。

同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据知乎，再唤醒消费者。

示例代码如下：

std::mutex g_cvMutex;
std::condition_variable g_cv;


std::deque<int> g_data_deque;
const int  MAX_NUM = 30;
int g_next_index = 0;

const int PRODUCER_THREAD_NUM = 3;
const int CONSUMER_THREAD_NUM = 3;

void producer_thread(int thread_id)
{
	while (true) {
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
		std::unique_lock<mutex> lk(g_cvMutex);
		if (g_data_deque.size() <= MAX_NUM) {
			g_next_index++;
			g_data_deque.push_back(g_next_index);
			std::cout << "producer_thread: " << thread_id << " producer data: " << g_next_index;
			std::cout << " queue size: " << g_data_deque.size() << std::endl;
		} else {
			g_cv.notify_all();
		}
	}
}


void consumer_thread(int thread_id) {
	while (true) {
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
		std::unique_lock <std::mutex> lk(g_cvMutex);
		if (!g_data_deque.empty()) {
			int data = g_data_deque.front();
			g_data_deque.pop_front();
			std::cout << "\tconsumer_thread: " << thread_id << " consumer data: ";
			std::cout << data << " deque size: " << g_data_deque.size() << std::endl;
		} else {
			g_cv.wait(lk);
		}
	}
}


producerconsumer::producerconsumer() {

	std::thread *producerthread[PRODUCER_THREAD_NUM];
	std::thread *consumerthread[CONSUMER_THREAD_NUM];


	for (int i = 0; i < PRODUCER_THREAD_NUM; i++) {
		producerthread[i] = new thread(producer_thread, ref(i));
	}

	for (int j = 0; j < CONSUMER_THREAD_NUM; j++) {
		consumerthread[j] = new thread(consumer_thread, ref(j));
	}
	
	for (int i = 0; i < PRODUCER_THREAD_NUM; i++) {
		producerthread[i]->join();
	}

	for (int j = 0; j < CONSUMER_THREAD_NUM; j++) {
		consumerthread[j]->join();
	}
}

• 程序中创建三个生产者线程，每个线程都会向 g_data_deque 这个双端队列中 push 数据
• 三个生产者线程push 的 int 类型使用的是全局变量，是在已有的基础上累加的 int 类型变量
• 程序中创建了三个消费者线程，只要双端队列不为空，就会将数据从双端队列中 pop 出来
• 生产者消费者会有抢占的操作，就是消费者并没有完全将队列消费完，让队列为空的时候，生产者再次将生产的内容放入队列，相当于有6个线程，在g_cvMutex 的保护下，生产和消费队列里面的内容

 执行结果如下：

4. 为什么条件变量要和互斥锁一起使用

首先要说明为什么要引入条件变量，如果某个线程需要等待某个条件成立，而这个条件又是其他线程给出的，其中的一种解决方案是：

threadA() {

lock
if(条件满足)
unlock
    excute code;
} else {
    sleep(n);
}
}

• 如果一直判断条件是否满足，线程没有阻塞等待，是非常浪费CPU资源的，所以引入了 sleep 函数，相当于 sleep 一段时间后再做判断
• 注意此时的判断条件是临界资源，需要锁的保护

引入条件变量后，若条件不满足，则相应线程被阻塞直至条件发生变化被唤醒，再去查询条件是否满足，避免了上述条件变化发生之前的无用查询包括加解锁

条件变量的引入，使多个线程以一种无竞争的方式等待条件的改变。

在使用 condition_variable 的 wait 函数之前，通常要进行条件判断，而此条件属于临界资源（在读取此条件的时候不能被打断，比如去更新这个条件），需要在访问之前加锁，这是为了保护临界资源的需要。

unique_lock<mutex> lock(mDisplayMutex);
if (mDisplayQueue.empty()) {

	cv.wait(lock);
}		

比如上面的代码中如果不加锁保护，在判断 mDisplayQueue.empty() 的条件成立后，此时线程被挂起，调度了另一个线程，另外的线程用于唤醒这个 condition_variable，此时当前线程因为还没有处于 wait 状态上（没有处于调度器的等待队列上），所以会丢失掉这个唤醒操作，如果这个唤醒操作只有一次，那么当前线程很可能永远处于阻塞等待的状态上。

所以 condtion_variable 加互斥锁的作用，就是保证全局条件和wait 的操作是原子操作

C++面试问题：为什么条件变量要和互斥锁一起使用？_条件变量为什么要和锁一起用_August8757的博客-CSDN博客