【C++11】线程库

一、thread类的基本介绍

在C++11之前，涉及到多线程的问题，都是和平台相关的，比如windows和Linux下各自有自己的接口，这使得代码的可移植性比较差，C++11中最重要的特性就是对线程进行了支持了，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库的线程，必须包含<thread> 头文件，底层是通过条件编译实现。总结：

c++ 复制代码

#ifdef _WIN32
	CreateThread()
#else
	pthread_create()
#endif

二、线程库thread

1.线程对象的构造方法

构造出一个线程对象，可以采用无参构造、带参构造和移动构造；

1.无参构造

c++ 复制代码

//1.无参构造，创建线程但是不启动
thread t1;

使用无参构造出来的线程对象没有关联任何线程函数，即没有启动任何线程。

2.带参构造

c++ 复制代码

//定义如下：
template<class Fn,class... Args>
explicit thread(Fn&& fn, Args&&... args);//万能引用(引用折叠)

//对比下C语言的
int pthread_create(pthread_t *tidp,const pthread_attr_t *attr)
void *(*start_rtn)(void*),void *arg); //函数指针+结构体

参数：

fn：它是一个万能引用 ，可以接收可执行对象：a.函数指针、b.仿函数、c.lambda、d.包装器。（替代函数指针），注意这里fn**不要有重载****
args：调用可调用对象fn时所需要的若干参数

c++ 复制代码

#include<thread>
void func(int x,const string& s) 
	cout <<this_thread::get_id()<<endl;
	cout << x << s << endl;
}
int main() {
	//带参构造
	thread t2(func, 10);
    
    //lamda表达式
    int n1=10,n2=20;
    int x=0;//但这里有线程安全问题！后面提到加锁解决
	thread t3([n1,&x]() {
        cout << n1 << endl;
        x++;
    });
    thread t4([n2,&x](){
        cout << n2 << endl;
        x++;
    });
    
    //thread t3(t1); 报错,线程防拷贝,但支持移动构造
    
    cout<<"线程1: "<<t2.get_id()<<endl;
    cout<<"线程2: "<<t3.get_id()<<endl;

	t2.join();
	t3.join();
    //不join可能就挂了,主线程结束回收资源,其他线程还未运行结束,join的时候主线程等待其他线程运行结束
	return 0;
}

3.移动构造

c++ 复制代码

#include<thread>
void func(int x,const string& s) {
	cout << x << endl;
}
int main() {
	//移动构造
	thread t0 = thread(func, 10);
	//直接以赋值的方式写的,就是移动构造
	t0.join();
	return 0;
}

//应用场景1，让空线程可以执行，这样就可以批量创建执行线程
int main(){
    size_t n;
    cin>>n;
    //创建n个线程执行Print
    vector<thread> vthd(n);
    size_t j=0;
    for(auto& thd:vthd){
        //移动赋值,匿名对象(将亡值)进行移动给无参线程对象
        thd=thread(func,10,"线程"+to_string(j++))
    }
    for(auto& thd:vthd){
        thd.join();
    }
    return 0;
}

//应用场景2,线程资源转移
int main(){
    thread t1(func,100,"我是xxx");
    thread t2(move(t1));
    t2.join();
    return 0;
}

注意：

线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态
如果创建线程对象时没有提供线程函数，那么该线程对象实际没有对象任何线程。
如果创建线程对象时提供了线程函数，那么就会启动一个线程来执行这个线程函数，该线程与主线程一起运行。
thread类是防拷贝的，不允许拷贝构造和拷贝赋值，但是可以移动构造和移动赋值，可以将一个线程对象关联线程的状态转移给其他线程对象（夺舍），并且转移期间不影响线程的执行。

总结：

带参构造，创建可执行线程
先创建空线程对象，移动构造或者移动赋值，把右值线程对象转移过去

2.thread提供的成员函数

成员函数	功能
get_id	获取线程id
joinable	判断该线程是否执行完毕，如果是则返回true，反之false
join	该函数调用后会阻塞住该线程，当该线程结束后，主线程继续执行
detach	将线程对象与被创建的线程进行分离，被分离后的线程不再需要调用join函数进行等待，即创建出来的线程的"死活"与主线程无关
swap	将两个线程对象关联的状态进行交换

joinable()函数判断线程是否是有效的，如果是以下任意情况，则线程无效

采用无参构造函数构造的线程对象
线程对象的状态已经转移给其他线程对象
线程已经调用join或者detach结束

3.获取线程id

调用thread的成员函数get_id可以获取线程的id，但该方法必须通过线程对象来调用get_id函数，如果要再线程对象关联的线程函数中获取线程id，可以调用this_thread命名空间下的get_id函数。比如：

c++ 复制代码

void func(){
    cout<<this_thread::get_id()<<endl;//获取线程id
}
int main(){
    thread t(func);
    t.join();
    return 0;
}

this_thread命名空间中还提供了以下三个函数：

函数名	功能
yeild	当前线程"放弃"执行，让操作系统调用另一个线程继续执行
sleep_until	让当前线程休眠到一个具体的时间点
sleep_for	让当前线程休眠一个时间段

4.线程函数的参数问题

线程函数的参数是以值拷贝的方式 拷贝到线程栈空间中的，因此：即使线程参数为引用类型，在线程中修改后也不能修改外部实参，因为实际引用的是线程栈中的拷贝，而不是外部实参 。这种情况在我们传递锁的时候非常常见！如：

我们想通过线程对一个变量进行修改，应该写法如下：

c++ 复制代码

void func(int& rx){
    //rx引用的不是n,而是n的拷贝，n的拷贝是临时对象
    rx++;
}
int main(){
    int n=0;
    thread t1(func,n);
    //n传递给thread的构造函数,thread的构造函数[模板参数]走一层完美转发,保持属性[生成了一个拷贝],底层很复杂!
    t1.join();
    cout<<n<<endl;
    return 0;
}

但是编译器直接报错了，常见的解决方式有下面三种：

1.采用C语言的方式，使用指针

c++ 复制代码

#include<thread>
void func(int* x) {
	(*x)++;
}
int main() {
	int n = 0;
	thread t1(func, &n);
	t1.join();
	cout << n << endl;
	return 0;
}

2.借助std::ref函数

当线程函数的参数类型为引用类型时，如果要想线程函数形参引用的是外部传入的实参，而不是线程栈空间中的拷贝，那么在传入实参时需要借助ref函数保持对实参的引用。

c++ 复制代码

void func(int& x){
    x++;
}
int main(){
    int n=0;
    thread t1(func,std::ref(n));
    t1.join();
    cout<<n<<endl;
    return 0;
}
//简单理解就是thread的构造函数进行了一次转发,导致x引用到的并不是n,而是我们在传递过程中的n的一个拷贝,导致后续对x操作并不会影响到n的值

3.借助lamda表达式

lamda的优势是不需要传参，直接捕获就可以了,所以不涉及坑

c++ 复制代码

int main(){
	int n=0;
    thread t1([&n]() {n++;});
    t1.join();
    
    cout<<n<<endl;
    return 0;
}

5.join和detach

启动了一个线程后，当这个线程结束的时候，如何去回收线程所使用的资源呢？thread库给我们两种选择：

1.join() 方式

join(): 主线程被阻塞，当新线程终止时，join()会清理相关的线程资源，然后返回，主线程再继续向下执行，然后销毁线程对象。由于join()清理了线程的相关资源，thread对象与已销毁的线程就没有关系了，因此一个线程对象只能使用一次join()，否则程序会崩溃

c++ 复制代码

#include<thread>
void func(int n) {
	//...
}
int main() {
	thread t1(func, 10);
	t1.join();
	t1.join();//程序崩溃

	return 0;
}

但采用join的方式结束线程，在某些场景下也可能会出现问题。比如在该线程被join之前，如果中途因为某些原因导致程序不再执行后续代码，这时这个线程将不会被join。

c++ 复制代码

void func(int n){
    for(int i=0;i<=n;i++){
        cout<<i<<endl;
    }
}
bool DoSomething(){
    return false;
}
int main(){
    thread t(func,20);
    
    if(!DoSomething()){
        return -1;
    }
    
    t.join();//不会被执行
    return 0;
}
//说明：如果DoSomething()函数返回false，主线程将会结束
//join()没有调用，线程资源没有回收，造成资源泄漏

因此：采用join() 方式结束线程时，join()的调用位置非常关键。为了避免该问题，可以采用RAII 的方式对线程对象进行封装；RAII，即Resource Acquisition Is Initialization，在初始化中获取资源，RAII机制，通过在栈上创建临时变量，这样临时变量就接管了堆上内存的控制权，当该临时变量声明周期结束时，则对应的堆上内存自然就被释放了。

比如：

c++ 复制代码

class myThread{
public:
    myThread(thread& t)
        :_t(t)
    {}
	~myThread(){
        if(_t.joinable())
            _t.join();
    }
    //防拷贝
    myThread(myThread const&)=delete;
    myThread& operator=(const myThread&)=delete;
private:
    thread& _t;
}

使用方式如下：

每当创建一个线程对象后，就用myThread类对其进行封装产生一个myThread对象。
当myThread对象生命周期结束时就会调用析构函数，在析构中会通过joinable判断这个线程是否需要被join，如果需要那么就会调用join对该线程进行等待。

例如刚才的代码中，使用myThread类对线程对象进行封装后，就能保证线程一定会被join：

c++ 复制代码

int main(){
    thread t(func,10);
    myThread q(t);//使用myThread对线程对象进行封装
    if(!DoSomething())
        return -1;
    return 0;
}

2.detach方式

detach()：该函数被调用后，新线程与线程对象分离，不再被线程对象所表达，就不能通过线程对象控制线程了，新线程会在后台运行，其所有权和控制权将会交给c++运行库。同时，c++运行库保证，当线程退出时，其相关资源的能够正确的回收。detach()函数一般在线程对象创建好之和就调用，因为如果不是join()等待方式结束，那么线程对象可能在新线程结束之前被销毁掉而导致程序崩溃。因为std::thread的析构函数中，如果线程的状态是joinable，std::terminate将会被调用，而terminate()函数直接会终止程序。

三、互斥量库------mutex

1.mutex的种类

在c++11中，Mutex总共包了四个互斥量的种类：

1.std::mutex（互斥锁）

mutex是C++提供的最基本的互斥量，该类的对象之间不能拷贝，也不能移动。mutex最常用的三个函数：

函数名	功能
lock()	上锁：对互斥量进行加锁
try_lock()	尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程不会被阻塞
unlock()	解锁：释放互斥量的所有权

线程函数调用lock()时，可能会发生以下三种情况：

如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用unlock之前，该线程一直拥有该锁；
如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住；
如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)；

线程函数调用try_lock()时，可能会发生以下三种情况:

如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用unlock释放互斥量；
如果当前互斥量被其他线程锁住，则当前调用线程返回false，而并不会被阻塞掉；
如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

2.std::recursive_mutex（递归互斥锁）

该锁专门用于递归函数中的加锁操作。

如果在递归函数中使用mutex互斥锁进行加锁，那么在线程进行递归调用时，可能会重复申请已经申请到但自己还未释放的锁，进而导致死锁问题。
recursive_mutex在函数再次加锁时会去判断申请加锁的线程是不是还是当前线程，如果还是当前线程，就不给予加锁操作。
除此之外，std::recursive_mutex的特性和std::mutex大致相同。

c++ 复制代码

void func(int i){//递归函数
    mutex //lock时就死锁了
    func(i-1);
}
//递归互斥锁在lock前判断再次加锁的是不是当前线程，如果还是的就不给予加锁操作。

3.std::timed_mutex（时间互斥锁）

比std::mutex 多了两个成员函数，try_lock_for()，try_lock_until()。

try_lock_for()

锁住一个时间段，要么手动的去unlock解锁，要么时间段到了解锁，我们需要使用**chrono::milliseconds(1000)**类似这样设置时间段的操作

try_lock_until()

锁住一个具体是时间点，要么手动的去unlock解锁，要么到时间点了解锁，可以使用chrono中的获取时间点的接口

4.std::recursive_timed_mutex（递归时间互斥锁）

recursive_timed_mutex 就是recursive_mutex 和timed_mutex 的结合，recursive_timed_mutex既支持在递归函数中进行加锁操作，也支持定时尝试申请锁。

加锁演示：我们想让两个线程对同一个变量进行++操作

c++ 复制代码

#include<thread>
int x = 0;
void func(int n){
	for (int i = 0; i < n; i++) {
		x++;
	}
}
int main() {
	thread t1(func, 1000);
	thread t2(func, 1000);
	t1.join();
	t2.join();
	cout << x << endl;
	return 0;
}

在上面的代码中，t1线程和t2线程都对x变量进行了++操作，本质上我们想要的结果是x=2000；但是运行结果如下：

我们发现结果并不是2000，提醒一下，我是在VS2022下进行测试的，有可能你在运行后结果刚好是2000，这时因为数据不是很大，你可以不断的把数据加大，然后再测试。

通过刚才的演示，我们发现结果不是2000，说明这两个线程在对同一个变量进行操作的时候，出现了问题；那是为什么呢？我在之前Linux的博客中有介绍过线程相关的知识，这里不细说；

首先++操作并不是原子操作，所谓原子操作就是一件事要么完成，要么就什么都不做；x++所对应的汇编代码是3句指令，两个线程在对x进行++操作的时候，由于没有外界的约束，就存在两个线程在同一时刻改变了这个变量，恰好这个x并没有发生什么实质性的变化；

这种情况下，我们就需要对这两个线程做一个约束，就是进行加锁的操作，加锁我们是在循环外面加还是在循环里面加呢？

c++ 复制代码

#include<mutex>
#include<thread>
int x = 0;
mutex mtx;
void func(int n){
	mtx.lock();//在循环外面加锁
	for (int i = 0; i < n; i++) {
		//mtx.lock();//在循环里面加锁
		x++;
		//mtx.unlock();
	}
	mtx.unlock();
}
int main() {
	thread t1(func, 1000);
	thread t2(func, 1000);
	t1.join();
	t2.join();
	cout << x << endl;
	return 0;
}

说明：针对这个案例加锁应该加在循环外面，效率更高

注：加锁的原则：锁的粒度尽可能的小（能给5行代码加锁，就不要给10行代码加锁）

1.如果在循环外面加锁：那么这个案例就失去了多线程的意义，虽然是两个线程，但由于在外面进行加锁，这两个线程就变成了并行运行（即：t1加完t2加），但是效率高；

2.如果在循环里面加锁：这种方式相比上面的，效率要低一些，但也是可以的。在里面进行加锁，x++这个代码，是执行的很快的，导致两个线程频繁的申请锁和释放锁、切换上下文；

加锁的操作，应该根据实际情况，酌情选择，在安全和效率上，我们优先选择前者；

2.lock_guard和unique_lock

如下代码，在使用互斥锁时，有时候会出现一些问题，比如刚才的代码，我们只是对x进行++操作，如果你在vector容器值插入数据（push_back）时，进行加锁，万一失败了，我们知道push_back失败时会抛异常，那么已经申请了互斥锁的线程，由于抛异常，导致不能释放锁，别的线程也就拿不到锁，这就导致了死锁的问题。

c++ 复制代码

int main(){
	mutex mtx;
    mtx.lock();
    //抛异常 这跟我们以前的new/delete的问题是一样的
    mtx.unlock();
    return 0;
}

为了解决这样的问题，C++11采用RAII[资源获得请求初始化]的方式对锁进行了封装，获取到的资源不要自己持有，而是交给一个类的对象去管理。避免抛异常时忘记释放资源而出问题。于是就出现了lock_guard 和unique_lock

c++ 复制代码

#include<mutex>
#include<vector>
mutex mtx;
void func(vector<int>& v) {
	mtx.lock();
	for (int i = 0; i < 100; i++) {
		v.push_back(i);
		if (i == 50) {//模拟抛异常，必然出现死锁问题
			return;
		}
	}
	mtx.unlock();
}
int main() {
	vector<int> v;
	thread t1(func, std::ref(v));//注意参数传递一定要ref!
	thread t2(func, std::ref(v));
	t1.join();
	t2.join();
	for (auto e : v) {
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

1.lock_guard介绍

lock_guard是C++11中的一个模板类，其定义如下：

c++ 复制代码

template<class Mutex>
class lock_guard
//只支持构造和析构

lock_guard类模板主要是通过RAII的方式，对其管理的互斥锁进行了封装。

在需要加锁的地方，用互斥锁实例化一个lock_guard对象，在lock_guard的构造函数中调用lock进行加锁。
当lock_guard对象出作用域前会调用析构函数，在lock_guard的析构函数中会调用unlock自动解锁，可以有效避免死锁问题。

通过这种构造对象时枷锁，析构对象时自动解锁的方式就有效的避免了死锁问题。比如：

c++ 复制代码

#include<mutex>
#include<vector>
mutex mtx;
void func(vector<int>& v) {
	lock_guard<mutex> lock(mtx);
	for (int i = 0; i < 100; i++) {
		v.push_back(i);
		if (i == 50) {//模拟抛异常，必然出现死锁问题
			return;
		}
	}
}
int main() {
	vector<int> v;
	thread t1(func, std::ref(v));
	thread t2(func, std::ref(v));
	t1.join();
	t2.join();
	for (auto e : v) {
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

2.模拟实现lock_guard

c++ 复制代码

#include<mutex>
template<class Lock>
class LockGuard {
public:
	LockGuard(Lock& lk)
		:_lk(lk){
        //锁不支持拷贝
		_lk.lock();//加锁
	}
	~LockGuard(){
		_lk.unlock();//解锁
	}
	LockGuard(const LockGuard&) = delete;
	LockGuard& operator=(const LockGuard&) = delete;
private:
	Lock& _lk;
    //引用类型的成员变量,跟const类型的成员变量一样，只能在初始化列表处初始化!初始化列表才是他们定义的地方,而引用和const只能在定义时初始化
};

3.unique_lock介绍

lock_guard的缺陷：太单一，用户没有办法对该锁进行控制【因为其内部只有构造和析构函数】，因此C++11又提供了unique_lock。与lock_guard类似，unique_lock类模板也是采用RAII的方式对锁进行了封装，并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作，即其对象之间不能发生拷贝。

在构造（或移动(move)赋值）时，unique_lock对象需要传递一个Mutex对象作为它的参数，新创建的unique_lock对象负责传入的Mutex对象的上锁和解锁操作。使用以上类型互斥量实例化unique_lock的对象时，自动调用构造函数上锁，unique_lock对象销毁时自动调用析构函数解锁，可以很方便的防止死锁问题。unique_lock在条件变量中也有很大应用

与lock_guard不用的是，unique_lock更加的灵活，提供了更多的成员函数：

加锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until和unlock。
修改操作：移动赋值、swap、release（返回它所管理的互斥量对象的指针，并释放所有权）。
获取属性：owns_lock（返回当前对象是否上了锁）、operator bool（与owns_lock的功能相同）、mutex（返回当前unique_lock所管理的互斥量的指针）。

四、原子性操作库------atomic

多线程最主要的问题是共享数据带来的问题（即线程安全）。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改是共享数据时，就会产生很多潜在的麻烦。

就连我们平时经常使用的i++都是原子的，可以看到是有3条指令构成的，并不是一次执行完。

c++ 复制代码

#include<iostream>
using namespace std;
#include<thread>
unsigned long sum = 0L;
void fun(size_t num) {
	for (size_t i = 0; i < num; i++)
		sum++;
}
int main() {
	cout << "Before joining, sum = " << sum << std::endl;
	thread t1(fun, 100000);
	thread t2(fun, 100000);
	t1.join();
	t2.join();
	cout << "After joining, sum = " << sum << std::endl;
	return 0;
}

上述代码中分别让两个线程对同一个变量sum进行了100000次++操作，理论上最终的sum的值应该是2000000，但最终打印出n的值缺是小于200000的。（这里存在的问题之前已经提到过了）

C++98中传统的解决方式：可以对共享修改的数据可以加锁保护。

c++ 复制代码

#include<iostream>
using namespace std;
#include<thread>
#include<mutex>
unsigned long sum = 0L;
std::mutex m;
void fun(size_t num) {
	for (size_t i = 0; i < num; i++) {
		//m.lock();
        while(!mtx.try_lock())
            this_thread::yield();
        //已经锁上了就把时间片让一让，但一般还是不会这样去处理
        
		sum++;//频繁的加锁解锁,不适合互斥锁
		m.unlock();
	}
}
int main() {
	cout << "Befor joining, sum = " << sum << std::endl;
	thread t1(fun, 100000);
	thread t2(fun, 100000);
	t1.join();
	t2.join();
	cout << "After joining,sum = " << sum << std::endl;
	return 0;
}

这里可以选择在for循环体里面进行加锁解锁，也可以选择在for循环体外进行加锁解锁。但效果终究是不尽人意的。

在for循环体里面进行加锁解锁会导致线程的频繁进行加锁解锁操作
在for循环体外面进行加锁解锁会导致两个线程的执行逻辑变为串行，而且如果锁控制的不好，还容易造成死锁。
这里最好不要使用互斥锁，而是使用自旋锁【适合短操作指令】。

为了解决上面的问题，C++11中引入了原子操作类型，使得线程间数据的同步变得非常高效。如下：

原子类型名称	对应的内置类型名称
atomic_bool	bool
atomic_char	char
atomic_schar	signed char
atomic_uchar	unsigned char
atomic_int	int
atomtic_uint	unsigned int
atomic_short	short
atomtic_ushort	unsigned short
atomic_long	long
atomtic_ulong	unsigned long
atomic_llong	long long
atomtic_ullong	unsigned long long
atomtic_char16_t	char16_t
atomtic_char32_t	char32_t
atomic_wchar_t	wchar_t

注意：需要用大括号 对原子类型的变量进行初始化 。程序员不需要对原子类型进行加锁解锁操作，线程能够对原子类型变量互斥访问。比如刚才的代码可以改为：

c++ 复制代码

#include<iostream>
using namespace std;
#include<thread>
#include<atomic>
atomic_long sum{ 0 };//或atomic_long sum={0}
//让这个变量的相关操作是原子的

void fun(size_t num) {
	for (size_t i = 0; i < num; i++)
		sum++;
}
int main() {
	cout << "Befor joining, sum = " << sum << std::endl;
	thread t1(fun, 100000);
	thread t2(fun, 100000);
	t1.join();
	t2.join();

	cout << "After joining,sum=" << sum << std::endl;
	return 0;
}

更为普遍的，程序员可以使用atomic类模板，定义出需要的任意原子类型。

c++ 复制代码

atmoic<T> t; // 声明一个类型为T的原子类型变量t

注意：

原子类型通常属于"资源型"数据，多个线程只能访问单个原子类型的拷贝，因此在C++11中，原子类型只能从其模板参数中进行构造，不允许原子类型进行拷贝构造、移动构造以及operator=等。
为了防止意外，标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了。
原子类型不仅仅支持原子的++操作，还支持原子的- -、加一个值、减一个值、与、或、异或操作。

五、条件变量库------condition_variable

1.信号量的介绍

condition_variable中提供了两种函数：Wait functions（等待函数）和Notify functions（通知函数）

wait系列成员函数：作用就是让调用线程进行阻塞等待

c++ 复制代码

//版本一
void wait(unique_lock<mutex>& lck);

//版本二
template<class Predicate>
void wait(unique_lock<mutex>& lck,Predicate pred);

调用第一个版本的wait函数时只需要传入一个互斥锁，线程调用wait后会立即被阻塞，直到被唤醒
调用第二个版本的wait函数时需要传入一个互斥锁，还需要传入一个返回值类型为bool的可调用对象，与第一个版本的wait不同的是，当线程被唤醒后还需要调用传入的可调用对象，如果可调用对象的返回值为false，那么该线程还需要继续被阻塞

notify系列成员函数

notify_one：唤醒等待队列中的首个线程，如果等待队列为空则什么也不做。
notify_all：唤醒等待队列中的所有线程，如果等待对象为空则什么也不做

2.信号量与锁的应用

经典笔试题：尝试用两个线程交替打印1-100的数字，要求一个线程打印奇数，另一个线程打印偶数，使用条件变量+锁来实现

c++ 复制代码

//t1打印奇数，t2打印偶数，交替打印
//如何保证t1先运行?
int main(){
    mutex mtx;
    int x=1;
    condition_variable cv;//保证交替
    bool flag=false;//保证t1先运行
    thread t1([&](){
        for(size_t i=0;i<100;i++){
            unique_lock<mutex> lock(mtx);
            while(flag):
            	cv.wait(lock);
            cout<<this_thread::get_id()<<x<<endl;
            ++x;
            flag=true;//下次让t2启动，自己锁上了,保证自己不会连续运行       
            cv.notify_one();//t1在notify_one的时候，t2还没有wait
        }
    });
    thread t2([&](){
        for(size_t i=0;i<100;i++){
            unique_lock<mutex> lock(mtx);
            while(!flag)//保证了第一次是t2上锁
            	cv.wait();
            cout<<this_thread::get_id()<<x<<endl;
            ++x;
            flag=false;
            cv.notify_one();
        }
    }); 
    return 0;
}

1.t1先运行，t2待定

假设t1先运行，t1先抢到lock，此时我们设置的flag是false，所以t1不会被while循环阻塞住，t1先打印线程id，结束后，将flag改成true，此时t2两种情况，我们根据t2不同的情况加以分析：

没启动起来，或者没有分到时间片

此时t1执行notify时发现并没有线程等待，于是出作用域解锁。因为t2没启动，所以t1又会抢到锁，但此时flag为true了，t1会进入while循环，被wait阻塞住。于是t1就会一直等待直到t2开始运行，t2总会开始运行，因为flag是true了，他不会wait，t2处理完之后，将flag改成false，再notify唤醒t1，后续就是类似的交替的走下去了。
运行起来，lock阻塞

t1运行结束唤醒t2，t2获取到锁，flag是true，t2不会被阻塞住【此时flag是true,如果有t1再次运行，将会被wait阻塞住】，开始处理，处理结束后把flag改成false，如果有t1在阻塞就唤醒t1，如果没有就结束。之后再交替到t1线程走下去。

2.t2先启动，t1待定

t2先启动，因为flag是false，所以t2被阻塞到while循环中的wait操作中，一直阻塞到有t1开始运行，t1处理完之后，将flag改为true，并且唤醒被阻塞住的t2，之后二者再继续交替运行即可。