这篇文章是笔者学习cpp多线程操作的第二篇笔记，没有阅读过第一篇的读者可以移步此处：
Cpp多线程（一）-CSDN博客
如果读者发现我的文章里有问题，欢迎交流哈！
一、如何控制线程呢？
c++11在std::this_thread名称空间（显然，这是一个嵌套在大名称空间里的小名称空间）内定义了一系列公共函数来管理线程。
1、get_id
获得当前线程id
2、yield
将当前线程时间片让渡给其他线程
3、sleep_until
当前线程休眠直到某个时间点
4、sleep_for
当前线程休眠一段时间
单纯看这些定义其实无法准确理解这些函数的意义。实践出真知，下面我们启动小实验来理解这些函数。
实验一：使用get_id
#include <iostream>
#include <thread>
void func1(void)
{
std::thread::id thread1_id=std::this_thread::get_id();
std::cout<<thread1_id<<std::endl;
}
int main(void)
{
std::thread thread1(func1);
thread1.join();
std::thread::id mainthread_id=std::this_thread::get_id();
std::cout<<mainthread_id<<std::endl;
} 输出结果：
2
1
由此我们发现：
1、get_id函数必须包含在名称空间std::this_thread里
2、get_id函数一般是没有参数的
3、查阅资料发现，get_id函数的返回值的具体类型由编译器定义。但是，任何编译器都定义了std::thread::id这一结构（类）来储存线程id。std::cout函数可以直接打印这一类型
4、在子线程和主线程中均可以使用get_id()
实验二：使用yield
yield函数的使用方法和get_id类似。
调用std::this_thread::yield()时，当前线程会主动放弃执行权，使得操作系统的线程调度器可以重新安排其他可运行的线程来执行。这样做可以提高多线程程序的执行效率和公平性。
需要注意的是，std::this_thread::yield()只是一个建议，具体的线程调度行为取决于操作系统和调度器的实现。在某些情况下，调度器可能会忽略该建议，继续让当前线程执行。
#include <iostream>
#include <thread>
#include <windows.h>
void func1(void)
{
std::this_thread::yield();
while(true)
{
std::this_thread::yield();
std::cout<<"thread1"<<std::endl;
Sleep(1000);
}
}
void func2(void)
{
while(true)
{
std::cout<<"thread2"<<std::endl;
Sleep(1000);
}
}
int main(void)
{
std::thread thread1(func1);
std::thread thread2(func2);
thread1.join();
thread2.join();
} 输出结果：
thread1thread2
thread2
thread1
thread2thread1......
可以看到，由于yield的作用，从第二次打印开始，thread2往往比thread1能够先进行打印。而如果注释掉std::this_thread::yield()，那么由于thread1比thread2先定义，thread1往往比thread2先打印。
实验三：使用sleep_for
下面的程序，主线程打印1 2 3，子线程打印4 5 6。为了让打印的数字是有顺序的，使用sleep_for函数让子线程暂停1秒，等待主线程的打印结束。（当然，现实中写程序肯定不会这么设计，我只是在呈现一种最简单的情况）
注意，这里使用了std::chorno::seconds，这是定义在chrono库中的一个类，用于表示时间。
#include <iostream>
#include <thread>
#include <chrono>
void func1(void)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
for(int i=4;i<=6;i++)
std::cout<<i<<std::endl;
}
int main(void)
{
std::thread thread1(func1);
for (int i=1;i<=3;i++)
std::cout<<i<<std::endl;
thread1.join();
} 输出结果：
1
2
3
4
5
6
由此我们发现：
1、sleep_for()函数的参数可以是std::chrono::seconds类型，也可以是chrono库中其他时间类型
2、sleep_for()函数没有返回参数
二、互斥锁mutex
1、为什么引入锁这个概念？
先看这段两线程轮流打印的代码：
#include <iostream>
#include <thread>
#include <windows.h>
void func1(void)
{
while(true)
{
std::cout<<"thread1"<<std::endl;
Sleep(1000);
}
}
void func2(void)
{
while(true)
{
std::cout<<"thread2"<<std::endl;
Sleep(1000);
}
}
int main(void)
{
std::thread thread1(func1);
std::thread thread2(func2);
thread1.join();
thread2.join();
} 正如我们之前所展示的那样，由于thread1和thread2轮流占用std::cout这一输出流对象，导致输出结果并不是我们想象的那样规整：
thread1
thread2
thread1
thread2
而是会出现这样的情况
thread1thread2
thread1
thread2
所以，我们引入mutex互斥锁这一概念。通过mutex锁的操作，使当thread1使用输出流对象时，把输出流对象锁住。这样，thread2将不被允许使用输出流对象。
#include <iostream>
#include <thread>
#include <windows.h>
#include <mutex>
std::mutex mtx;
void func1(void)
{
while(true)
{
mtx.lock();
std::cout<<"thread1"<<std::endl;
Sleep(1000);
mtx.unlock();
}
}
void func2(void)
{
while(true)
{
mtx.lock();
std::cout<<"thread2"<<std::endl;
Sleep(1000);
mtx.unlock();
}
}
int main(void)
{
std::thread thread1(func1);
std::thread thread2(func2);
thread1.join();
thread2.join();
} 读者可以自行验证上面这段代码，输出结果将非常规整，不会出现上面那种情况。这就使锁所产生的效果。
2、如何理解锁的概念？
如果把内存比作一个个小房间，那么各个线程就要在各个房间里存取数据。如果两个线程同时存取数据，可能会造成一些错误。所以，当线程1在这个房间里存储数据时，就需要把这个房间锁住。线程2若要使用这个房间的数据，就要在外面等待。（具体的方式有线程阻塞，停止执行，即互斥锁；也有循环等待直到锁被打开，即自旋锁）
3、C++如何定义锁？
c++11的mutex库中定义了std::mutex类，作为操作锁的句柄，用来管理锁的各种行为。mutex类的具体实现对用户封闭，下面只介绍一些对外的接口（API）。了解这些接口（包括mutex的构造函数和公有函数）即可实现锁的操作。
--实例化锁对象
通常把锁对象实例化为全局变量：
#include <mutex>
//mutex类被定义在mutex中
std::mutex mtx;
void func()
{}
int main()
{}
--最简单的上锁和解锁
对mtx使用lock()方法，可以实现上锁操作。使用unlock()方法，可以解锁
假若线程1运行的是func函数，value是定义在全局的变量。
int value=0;
std::mutex mtx;
void func()
{
mtx.lock();
value+=1;
mtx.unlock();
}那么，在func1访问改写value变量前，添加mtx.lock()语句可以对value变量上锁；此时只有线程1可以访问value，确保了数据安全。改写完毕，使用mtx.unlock()解锁。
可以形象地理解mtx.lock()——这句话就好像给线程1一大把锁和钥匙，线程1要访问哪些变量（特指别的线程也可以访问地公共变量），就在访问时加一把锁，直到访问完成，才把它解开。在此期间，如果线程2也要访问这个变量，就会被暂停.直到线程1处理完毕，线程2才能被唤醒继续执行。
所以，锁这个类写的非常智能，优先拿到锁的线程要访问哪些对象，就把哪些对象锁住。
mtx.lock();
//这中间出现的变量，资源全部被锁保护，别人不许碰！！！
mtx.unlock();
//这之后出现的变量，就不一定是当前线程优先访问了！！！注意，解锁是非常重要的。试想，你使用一个房间后不解锁，直接翻窗走了（额，有点滑稽。但如果一个函数结束了，就是这样，直接消失），那么这个房间就一直锁住了，别人没有钥匙，不能用了。
--不同线程存在竞争关系
#include <iostream>
#include <thread>
#include <windows.h>
#include <mutex>
std::mutex mtx;
void func1(void)
{
while(true)
{
mtx.lock();
std::cout<<"thread1"<<std::endl;
Sleep(1000);
mtx.unlock();
}
}
void func2(void)
{
while(true)
{
mtx.lock();
std::cout<<"thread2"<<std::endl;
Sleep(1000);
mtx.unlock();
}
}
int main(void)
{
std::thread thread2(func2);
std::thread thread1(func1);
thread1.join();
thread2.join();
} 还是刚刚这一段代码，我们交换线程1和2的注册顺序。发现输出结果就变成了
thread2
thread1
thread2
......
这是由于thread2先注册，可以先抢夺锁的资源，拿到锁后，过河拆桥。不让thread1访问输出流对象了！（当然，thread2访问完毕后，还是要按照规则去唤醒thread1，所以第二个执行的必须是thread1线程）
4、其他方式实现锁
这里介绍mutex库中一个模板类——std::lock_guard。顾名思义，这个类模板实例化后能像保安一样帮我锁门开门（太形象了！）
把mtx.lock()出现的位置使用下面的语句：
std::lock_guard<std::mutex> mylock_guard(mtr);这是在使用类的构造函数，参数是之前定义的锁mtr。之后，在函数作用域中出现的全局变量和公共资源都会被锁住。
下面的示例代码就用两种方式实现了锁：
#include <iostream>
#include <thread>
#include <windows.h>
#include <mutex>
std::mutex mtx;
void func1(void)
{
while(true)
{
std::lock_guard<std::mutex> my_guard(mtx);
std::cout<<"thread1"<<std::endl;
Sleep(1000);
}
}
void func2(void)
{
while(true)
{
mtx.lock();
std::cout<<"thread2"<<std::endl;
Sleep(1000);
mtx.unlock();
}
}
int main(void)
{
std::thread thread2(func2);
std::thread thread1(func1);
thread1.join();
thread2.join();
} 可以发现，guard的作用区域是while循环内部。
这就像你雇佣了一群保安大叔，当你进入某个房间（内存）时，帮你锁上门；等你出来，自动帮你把门解锁了（怎么和现实相反了？？？）。
参考资料：
『面试问答』：互斥锁、自旋锁和读写锁的区别是什么？_哔哩哔哩_bilibili文章来源：https://www.toymoban.com/news/detail-807200.html
C++多线程详解（全网最全） - 知乎 (zhihu.com)文章来源地址https://www.toymoban.com/news/detail-807200.html
到了这里，关于cpp多线程（二）——对线程的控制和锁的概念的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
