c++11笔记 跨平台线程池

1. 左值：

简单的说，可以放在等号左边的变量可以称之为左值，可以对该变量进行取地址运算的是左值,左值在内存中有确切的地址，可以长期存在，拥有具体的名字的。

比如

int a = 10;
int *p = &a;//这里的a就是左值

2. 右值:

简单的说可以放到等号右边的值叫做右值，右值不能进行取地址运算，右值在内存中没有确切的地址，不能再内存中长期存在，没有具体的名字，是一个临时对象。

比如：

cout << 10 << endl;
cout << &10 <<endl;//error

3. 变长参数模板：
模板参数包：
 

template<typename F, typename... Args>
void Show(F&& f, Args&&... args)//函数名，以及函数的参数
{

}

4. 万能引用，引用折叠和完美转发

万能引用，引用折叠，完美转发的关系-CSDN博客

5. 方法bind

bind(fuction, parameter,...);//将参数绑定在函数中，生成一个新的可调用对象

可以使用placeholders_1、placeholders_2...作为占位符，表示新的可调用对象调用时，由外部提供值。（placeholders就是占位符的意思）

6. 模板类fuction

模板类fuction是一个函数封装器，<>模板参数限制了fuction模板类对象的使用方法(返回值是什么，参数列表是什么)，但这不意味着对封装在fuction中的函数参数和返回值进行限制。我们可以像使用函数一样使用fuction模板类对象。相当于对函数再进行封装了一遍，使得我们可以以调用function对象的方式来调用该对象中封装进去的函数。

比如:

std::fuction<void()>(std::bind(forward<F>(f), forward<Args>(args));
//利用完美转发保存参数的原始类型，将参数bind到函数上，生成一个新的函数对象
//再将函数对象封装进fuction函数中
//可以以不带参数和返回值的方式调用如:fuction();

condition_variable

condition_variable可以用来定义条件变量，条件变量可以多线程中唤醒和堵塞线程，可以使用condition.wait(lock, fuction)

第一个参数是锁lock，我们在使用wait的使用将线程堵塞，不需要锁，因此将锁传进去就会解开锁（我们不希望线程在持有互斥锁的时候进入休眠）。第二个参数是可调用对象(函数，函数指针，函数对象，lambda表达式)，该可调用对象的返回值必须是Bool类型，当返回值为true且被notify通知的时候，将会上锁，等待取消，线程继续执行，否则线程将一直堵塞。（通知和堵塞机制是为了，解决线程被在获得cpu资源的时候，不断循环等待（看看资源准备好了吗，一直访问资源区），等待生产者将任务加入到任务队列中，我们都知道这样的繁忙的等待是非常低效的，通知和堵塞机制就是为了解决这种问题）

为什么线程执行到wait的时候解锁后进入休眠，这是因为这样就可以做到只有生产者将生产资料放入到任务队列钟后，被通知的线程可以继续执行，其他没有被通知的线程继续等待，即按照拟定的序列进行执行。

也就就是说condition_variable会有一个上锁和解锁的操作，当执行sleep(堵塞)的时候，锁将会被释放，当被唤醒的时候，锁将会被锁上，然后判断可调用对象，来判断是否可以继续执行，可调用对象返回false则继续堵塞，返回true则执行。

第二个参数是为了解决虚假唤醒(spurious wake)的，这样只有继续执行的条件被满足的时候，线程才可以继续运行。也就是在唤醒后再进行一次判断，防止线程对没有准备好的资源进行操作。

C++并发编程之 6_Condition Variable_哔哩哔哩_bilibili

7. emplace_back和push_back的区别:

emplace_back和push_back在大部分情况下是等价的，只有在直接调用构造函数创建对象时，emplace_back更高效。然而，使用emplace_back时需要注意可能出现的危险性，因为它的行为可能不符合预期。因此，推荐默认使用push_back，只有在需要临时创建对象时才使用emplace_back。

push_back和emplace_back的区别在于它们调用的构造函数不同，线程不支持push_back因为thread将复制构造函数和移动构造函数以及赋值运算符都给delete（禁止）了，因此我们应该使用emplace_back。

8. 时间库chrono

用来时间管理的，在标准库中

如:

this_thread:sleep_for(std::chrono::second(1));
//让线程休息一秒钟

9. unique_lock

一种互斥量封装类，创建该封装类对象的时候，会对互斥量进行加锁，当对象结束使用后，自动调用析构函数进行解锁。相对去auto_lock，该unique_lock更加灵活，提供更多实用的方法，比方说，try_lock尝试加锁，得就true不得就false，try_lock_for，一直加锁，直到加锁成功或者超时，以及try_lock_until等等

10. 什么是虚假唤醒（spurious wakeup）？

虚假唤醒就是你（作为一个线程）收到了其他线程传来的唤醒信号，但是你唤醒后发现别的线程处理的比你快，此时没有数据被可以用于操作，这种情况的发生是预期之外的，被称为虚假唤醒。此外，被唤醒的线程中，只有一部分线程是真正满足唤醒条件的，剩下的部分即使被唤醒，也无法进行有效的操作，这些被唤醒但无法操作的线程，也被视为发生了虚假唤醒。

解决虚假唤醒的常用手段是在检查条件时使用循环（通常是while循环），而不是只进行一次检查。这样，即使发生了虚假唤醒，线程也会再次检查条件，如果条件不满足，线程会再次进入等待状态。

c++11推出了一种更加简单的方式来解决虚假唤醒（唤醒后没有数据可以供该线程来使用），那就是condition_variable中的wait，被唤醒后会先判断wait中可调用对象的返回值是否为true，只有为true的时候，该线程才会继续执行，否则该线程将会被继续堵塞。

#include <condition_variable>

condition_variable condition;

std::unique_lock<std::mutex> lock(mutex)
condition.wait(lock, [this]{return !tasks.empty();});

有了以上的前置知识

手写一个线程池：

#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <functional>
#include <condition_variable>


class ThreadPool
{
	public:
		//线程池的构造函数，用来创建线程池
		ThreadPool(int ThreadNum) : stop(false)
		{
			for(int i = 0; i < ThreadNum; i++)
			{
				//创建线程: 线程的入口函数，因为thread已经将复制构造函数和移动构造函数给delete了，只能使用emplace
				threads.emplace_back([this] {
						while (true)
						{
							std::unique_lock<std::mutex> lock(mutex);
							condition.wait(lock, [this] {return stop || !tasks.empty(); });//只有lambda表达式返回true的时候继续执行，否则sleep,解决虚假唤醒问题
							if (stop && tasks.empty())//当线程池停止且任务队列为空的时候，线程结束;
							{
								return;
							}
							std::function<void()> task(std::move(tasks.front()));//使用移动构造函数来创建task
							tasks.pop();
							lock.unlock();
							task();//任务执行的时候不需要锁，应该将锁进行释放
						}					
					});
			}

		}
		//边长参数模板，万能引用，引用折叠，完美转发
		template<typename F, typename... Args>
		void enqueue(F&& f, Args&&...args)
		{
			std::function<void()> task(std::bind(std::forward<F>(f), std::forward<Args>(args)...));//forward完美转发，保留原始类型，作为参数，bind根据参数生成新对象，该新对象作为function的参数
			{
				std::unique_lock<std::mutex> lock(mutex);
				tasks.emplace(std::move(task));//移动构造函数生成新对象
			}
			condition.notify_one();//通知一个唤醒;
			
		}

		~ThreadPool()
		{
			{
				std::unique_lock<std::mutex> lock(mutex);//因为stop是共享变量，使用之前应该先上锁
				stop = true;
			}//代码块运行结束，lock锁自动调用析构函数进行解锁
			condition.notify_all();//唤醒所有线程
			for (auto& thread : threads) //让每个线程运行到停止
			{
				thread.join();
			}
		}


	private:
		std::vector<std::thread> threads;//线程数组;
		std::queue<std::function<void()>> tasks;//任务队列;
		std::condition_variable condition;
		std::mutex mutex;
		bool stop;

};

int main(void)
{
	ThreadPool pool(4);
	for (int i = 0; i < 10; i++)
	{
		pool.enqueue([i] {
			std::cout << "Task: " << i << " is running." << "Thread Id: " << std::this_thread::get_id() << std::endl;
			std::this_thread::sleep_for(std::chrono::seconds(1));
			std::cout << "Task: " << i << "is done" << std::endl;
			});
	}

	return 0;
}