Studying-多线程学习Part3 - condition_variable与其使用场景、C++11实现跨平台线程池

来源：多线程学习

目录

condition_variable与其使用场景 

生产者与消费者模型

C++11实现跨平台线程池 

---

condition_variable与其使用场景 

生产者与消费者模型

生产者-消费者模式是一种经典的多线程设计模式，用于解决多个线程之间的数据共享和协作问题。在生产者-消费者模式中，有两类线程：生产者线程和消费者线程。它们之间通过共享一个缓冲区（或队列）来协作，生产者将数据放入缓冲区，消费者从缓冲区取出数据并进行处理。

生产者-消费者模式的主要目标是实现生产者和消费者之间的解耦，使它们可以独立地进行工作，从而提高系统的性能和可维护性。

condition_variable的步骤如下：

1. 创建一个condition_variable对象
2. 创建一个互斥锁 mutex 对象，用来保护共享资源的访问。

3. 在需要等待条件变量的地方：使用unique_lock<mutex>对象锁定互斥锁，并调用condition_variable::wait()、condition_variable::wait_for()或condition_variable::wait_until()函数等待条件变量。

4. 在其他线程中需要通知等待的线程时，调用condition_variable::notify_one()或condition_variable::notify_all()函数通知等待的线程。

代码参考：

#include <iostream>
#include <thread>
#include <mutex>
#include <string>

#include <condition_variable>
#include <queue>
using namespace std;

queue<int> g_queue; //任务队列
condition_variable g_cv;
mutex mtx;


//实现生产者
void Producer() {
	for (int i = 0; i < 10; ++i) {
		{
			unique_lock<mutex> lock(mtx);
			g_queue.push(i);
			//加任务的时候哦，需要通知消费者来取任务
			g_cv.notify_one(); 
			cout << "Producer: " << i << endl;
		}
		this_thread::sleep_for(chrono::microseconds(100)); //休眠100ms
	}
}

//实现消费者
void Consumer() {
	while (1) {
		unique_lock<mutex> lock(mtx);

		//如果队列为空，理应需要等待
		//第二个参数是函数指针（可以用lambda表达式）返回的true则不堵塞，false则阻塞，注意阻塞的时候会释放资源所以不会发生死锁
		g_cv.wait(lock, []() {return !g_queue.empty(); });
		int value = g_queue.front();
		g_queue.pop();

		cout << "Consumer：" << value << endl;
	}
}

int main() {
	thread t1(Producer);
	thread t2(Consumer);
	t1.join();
	t2.join();
	return 0;
}

---

C++11实现跨平台线程池 

线程池符合的就是生产者和消费者模型。线程池提前维护一个线程的数组和一个任务队列，不同的让线程去完成队列里的任务。

使用线程池可以解决不断销毁创建线程的消耗。

代码参考：

//实现线程池
#include <iostream>
#include <thread>
#include <mutex>
#include <string>
#include <condition_variable> //条件变量
#include <queue>
#include <thread>
#include<functional> //对象包装器
using namespace std;

//创先线程池的类
class ThreadPool {
public:
	//构造函数
	ThreadPool(int numThreads) : stop(false) {
		for (int i = 0; i < numThreads; i++) {
			threads.emplace_back([this] {
				while (1) {
					unique_lock<mutex> lock(mtx); //互斥锁，因为线程是操作任务队列的
					condition.wait(lock, [this] { //判断任务队列里面是否有任务，且是否停止
						return !tasks.empty() || stop;
						});

					if (stop && tasks.empty()) { //如果线程终止了，则结束线程
						return;
					}

					function<void()> task(move(tasks.front())); //拷贝构造，但是使用move能够防止赋值
					tasks.pop();
					lock.unlock(); //取完任务之后，解锁，让其他线程可以接续取任务
					task();
				}
				});
		}
	}
	//析构函数
	~ThreadPool() {
		//手动加{}提供作用域
		{
			unique_lock<mutex> lock(mtx);
			stop = true;
		}

		condition.notify_all(); //通知线程完成所有任务
		for (thread& t : threads) { //这个地方要使用引用，因为线程是不可以复制的
			t.join();
		}
	}
	//加任务，加函数，使用模版可以实现可变参数
	template<class F,class... Args>
	void enqueue(F&& f, Args&&...args) { //&&万能引用
		function<void()> task = bind(forward<F>(f), forward<Args>(args)...);
		{
			unique_lock <mutex> lock(mtx);
			tasks.emplace(move(task));
		}
		condition.notify_one();
	}


private:
	vector<thread> threads; //线程数组
	queue<function<void()>> tasks; //任务队列，队列里面包含的是函数模版
	mutex mtx; //互斥量
	condition_variable condition; //条件变量

	bool stop;

};

int main() {
	ThreadPool pool(4);
	for (int i = 0; i < 10; i++) {
		pool.enqueue([i] {
			cout << "task: " << i << " start" << endl;
			this_thread::sleep_for(chrono::seconds(1));
			cout << "task: " << i << " down" << endl;
			});
	}

	return 0;
}

知识点汇总：

1. thread线程库：vector<thread> threads; //线程数组

2.function函数模版：

3.mutex互斥锁

4.condtion_variable 条件变量：解决生产者消费者问题

5.lambda表达式-匿名函数

6.move移动语义

7.template<class F, class...Args>

8.&&右值引用，万能引用

9.bind函数适配器，绑定函数和函数参数

10.forward完美转发，配合&&实现万能引用