C++ 线程同步 异步 阻塞 非阻塞概念介绍 及 C++ 实践

基础概念介绍

基础概念介绍参考博文：https://www.cnblogs.com/mhq-martin/p/9035640.html
我们经常看到线程同步 进程同步 有时候可能还会听到线程异步之类的说法，这些概念容易让人混淆，所以首先我们把这些概念拆开来一个一个看，然后他们组合起来应该就容易理解了
同步
就是按照顺序一件一件的做。专业一点就是如果调用了一个函数，就需要等这个函数运行结束，才能执行后面的代码。
异步
就是很多事情一起做，顺序不能确定。专业一点就是，调用了一个函数，不管这个函数有没有执行完，就接着执行后面的代码，那如果需要知道这个函数运行的结果的话，就需要这个被调用的函数主动通知调用者，调用者也需要检查是否被通知。
多线程
多线程本身就是一种异步操作，多线程是实现异步的一种手段。
线程同步
多线程中通过互斥量、信号量等方式控制线程运行的顺序，以避免对共享变量的破坏。
阻塞
当前线程因为等待某个不能被立即执行的操作而陷入等待状态
非阻塞
当前线程不会因为等待一个不能被立即执行的操作而停止执行后面的代码

总结
同步容易阻塞
异步不容易阻塞
但是也不完全如此，异步也可以阻塞。

c++ 11 中多线程以及异步处理

C11中创建多线程

直接创建thread对象就可以。

#include<thread>
#include<iostream>

using std::cin;
using std::cout;
using std::endl;

void func()
{
   
	cout << "this is func()" << endl;
}

void func2()
{
   
	std::this_thread::sleep_for(std::chrono::seconds(3)); //线程休眠3秒钟
	cout << "this is func2()" << endl;
}

int main()
{
   
	std::thread t(func);
	std::thread t2(func2);
	std::this_thread::sleep_for(std::chrono::seconds(1)); //当前线程休眠1秒钟
	cout << "this is main" << endl;
	t.join();//等待线程t1结束，如果不等待线程结束，就可能产生线程对象已经删除，但是线程还没有执行结束
	t2.join(); //等待线程t2结束
}

**备注：**可以用detach函数就创建的线程与当前线程分离，但是一旦分离就不能再有直接的联系了

线程的一些函数使用

线程同步

互斥量

互斥量是一种同步原语，一种线程同步的手段，用来保护多线程对共享区域的访问。
一共有四种互斥量
std::mutex 独占的互斥量 ，不能递归调用，（同一个线程不能自己调用自己）
std::timed_mutex带超时的互斥量
std::recursive_mutex 递归互斥量
std::recursive_timed_mutex 带超时的递归回归量

std::mutex尝试

#include<thread>
#include<iostream>
#include<mutex>
#include<chrono>

using std::cin;
using std::cout;
using std::endl;

std::mutex g_lock;

void func()
{
   
	g_lock.lock();

	cout << "entered thread " << std::this_thread::get_id() << endl;

	std::this_thread::sleep_for(std::chrono::seconds(1));

	cout << "leaving thread " << std::this_thread::get_id() << std::endl;

	g_lock.unlock();
}

int main()
{
   
	std::thread t1(func);
	std::thread t2(func);
	std::thread t3(func);

	t1.join();
	t2.join();
	t3.join();

}

递归的独占锁

要注意下面的代码实际上都是在同一个线程中的

//*******************************递归独占互斥量*********************
#include<thread>
#