C++ 多线程（一）

1.std中的thread API 介绍

开启一个线程

如下是定义一个线程

std::thread Thread1(ThreadFunc1)

其开始运行有两种方式，一个是阻塞当前调用进程，一个是异步的方式不会阻塞当前调用的进程

join会阻塞当前调用的进程

Thread1.join()

detach不会阻塞当前调用进程

Thread1.detach()

获取线程信息API

获取线程ID

Thread1.get_id()

判断线程是否是可启用的

Thread1.joinable() 

这样输出的值是true

	std::thread Thread1(ThreadFunc1);
	cout << Thread1.joinable() << endl;

如果传入的执行参数为空则是不可启用

	std::thread Thread1;
	cout << Thread1.joinable() << endl;

如果想获取计算机能创建的线程数

Thread1.hardware_concurrency()

获取当前线程ID

 std::this_thread::get_id()

使当前线程睡眠n秒
有两种方式，一种是std的，一种是windows底层的

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

注意windows的睡眠需要引用头文件Windows.h

#include <Windows.h>
Sleep(1000);

交换两个线程

std::thread Thread1(ThreadFunc1)
std::thread Thread2(ThreadFunc2)
Thread1.spawn(Thread2)

2.向线程里传递参数的方法

先定义要在子线程执行的方法

void Func1(int a, const string& b)
{
	cout << a << endl;
	cout << b << endl;
}

第一种方式（在创建线程的构造函数后携带参数）

	std::thread NewThread1(Func1, 1, "Hello");
	NewThread1.join();

第二种方式（Lambda）

	int a = 100;
	std::thread NewThread2([&](int value1,const string& value2)
		{
			cout << "=====================" << endl;
			cout << a << endl;
			cout << value1 << endl;
			cout << value2 << endl;
		},2,"World");
	NewThread2.join();

第三种方式（成员函数）

class FTestClass
{
public:
	void Run(int a,const string& b)
	{
		cout << a << endl;
		cout << b << endl;
	}
};

	FTestClass TestClass;
	std::thread NewThread3(&FTestClass::Run, &TestClass, 3, "TestClass");
	NewThread3.join();

3.互斥锁

为了避免多线程之间的资源竞争自然需要这种互斥的锁

使用前需要引用头文件

#include <mutex>

mutex mx;
void NewThreadFunc()
{
	mx.lock();

	cout << "等待2s" << endl;
	std::this_thread::sleep_for(chrono::seconds(2));

	mx.unlock();
}

	for (size_t i = 0; i < 5; i++)
	{
		std::thread th(NewThreadFunc5);
		th.detach();
	}

最后我们会发现每隔2s输出一次信息

我们每次使用锁都需要lock 和 unlock 这是十分不便利的，而且如果我们忘记解锁就会死锁
我们可以使用析构来实现这种自动解锁的方式

struct FEvent
{
	FEvent()
	{
		m.lock();
	}

	~FEvent()
	{
		m.unlock();
	}

	static mutex m;
};
mutex FEvent::m;

再使用宏包裹一下

#define LOCK_TEST FEvent LockEvent;

如下是在线程执行的函数，只需要定义一行就可以自动解锁

void NewThreadFunc()
{
	LOCK_TEST

	cout << "等待2s" << endl;
	std::this_thread::sleep_for(chrono::seconds(2));
}

4.try_lock

try_lock 返回bool 值，是否能上锁

static mutex mx;
void NewThreadFunc2()
{
	if (mx.try_lock())
	{
		cout << "等待2s" << endl;
		std::this_thread::sleep_for(chrono::seconds(2));
		mx.unlock();
	}
	else 
	{
		cout << "锁被使用" << endl;
	}
}

	for (size_t i = 0; i < 5; i++)
	{
		std::thread NewThread2(NewThreadFunc2);
		NewThread2.detach();
	}

最后输出我们会发现只打印了一个等待2s 和四个锁被使用

5.挂起和唤醒线程

定义在子线程执行的函数

void NewThreadFunc3()
{
	while (true)
	{
		Sleep(1000);
		cout << "Hello" << endl;
	}
}

SuspendThread 用于挂起线程
ResumeThread 用于唤醒线程

	std::thread th(NewThreadFunc3);
	SuspendThread(th.native_handle());
	std::this_thread::sleep_for(chrono::seconds(2));
	ResumeThread(th.native_handle());

6.将主线程资源移动到其他线程

定义在子线程执行的函数

void NewThreadFunc4(const string& Value)
{
	cout << Value << endl;
}

	std::thread th1(NewThreadFunc4,move("Hello world"));
	std::thread th2 = move(th1);
	th2.detach();

将th1的所有权转移给th2。此时，th1不再代表任何线程（相当于th1处于“空”状态），而th2现在代表原来th1所代表的线程。这是因为std::thread是不可复制的，但可以移动。所以，这里通过移动赋值（或移动构造）将th1的线程所有权转移给th2。

7.lock_guard

类似我们之前自己封装的自动解锁的锁，不要手动调用unlock，函数执行完毕自动析构

mutex mx;
void NewThreadFunc5()
{
	lock_guard<mutex> lock(mx);

	cout << "Hello world" << endl;

	Sleep(2000);
}

	for (size_t i = 0; i < 5; i++)
	{
		std::thread th(NewThreadFunc5);
		th.detach();
	}

每隔2s输出一次一共输出了5次

8.unique_lock

unique_lock 相对于上面的 lock_guard 多了更多的功能API 可以更自由丰富的操作锁

defer_lock 此参数是延时的意思，锁并不是立马生效，需要手动lock

unique_lock 也是过了作用域会自动解锁

static mutex mt;
void Func1()
{
	unique_lock<mutex> lock1(mt,defer_lock);

	// 不需要上锁的函数
	cout << "这是不需要上锁的函数" << endl;

	lock1.lock();

	cout << "这是需要上锁的函数" << endl;

	lock1.unlock();

	//lock2.try_lock_until(); 锁到某个时间点
	//lock2.release(); 释放
	//lock2.mutex();拿到锁本体
	//lock2.swap(); 交换
	//lock2.owns_lock(); 判断是否锁住
}

下面演示一个unique_lock 的 try_lock_for()方法

static timed_mutex timeMt;
void Func2()
{
	unique_lock<timed_mutex> lock2(timeMt, defer_lock);
	if (lock2.try_lock_for(chrono::seconds(2)))
	{
		cout << "锁住2s后" << endl;
		this_thread::sleep_for(chrono::seconds(1));
	}
	else
	{
		cout << "锁正在被占用" << endl;
	}
}

	for (size_t i = 0; i < 5; i++)
	{
		thread th(Func2);
		th.detach();
	}

我们会发现输出了2个锁住2s后和3个锁正在被占用，是因为这个锁定义了锁住的时间为2s，当第一次运行后只执行了1s第二次进入仍然没超过定义的锁的2s所以可以进入，而之后都超过2s了，故无法进入了。

9.call_once

顾名思义就是无论调用多少次只执行一次

once_flag oneFlag;
void Func3()
{
	call_once(oneFlag, []()
		{
			cout << "运行一次" << endl;
		});
}

	for (size_t i = 0; i < 5; i++)
	{
		Func3();
	}

10.condition_variable

条件变量，一个地方可以等待直到通知这个等待就可以执行等待之后的代码

mutex tx1;
condition_variable cv;
void Func4()
{
	Sleep(1000);
	cv.notify_one();
	Sleep(1000);
}

	std::thread th(Func4);
	th.detach();

	unique_lock<mutex> Lock1(tx1);
	cv.wait(Lock1);
	cout << "运行Wait之后" << endl;

notify_one 是一个，还有多个版本notify_all