C++语言级别的多线程

1.线程概念

好处：可以跨平台：windows / linux / mac
线程间的互斥：mutex / lock_quard / unique_lock
线程间的通信：condition_variable
atomic : 原子类型 基于CAS操作的原子类型 线程安全的
sleep_for :睡眠

C++语言层面调用thread，在windows操作系统上底层调用的是createThread，在linux下调用的是pthread_create。可以通过编译器的编译，加一个宏，可以识别当前的操作系统，可以通过适配在语言层面编写的thread底层自动调用相应的函数。本质上还是在调用操作系统线程创建的API。就是语言层面加了一层封装，对于开发者更友好

2.线程的基本操作

线程内容：

• 1.怎么创建启动一个线程
  std: :thread定义一个线程对象，传入线程所需要的线程函数和参数，线程自动开启
• 2.子线程如何结束
  子线程函数运行完成，线程就结束了
• 3.主线程如何处理子线程
• • t.join() : 等待t线程结束，当前线程继续往下运行
• • t.detach() : 把t线程设置为分离线程，主线程结束，整个进程结束,所有子线程都自动结束了!

#include<iostream>
#include<thread>
using namespace std;

void threadHandle1()
{
	//让子线程睡眠2秒
	std::this_thread::sleep_for(std::chrono::seconds(2));

	cout << "hello thread1!" << endl;
}

int main()
{
	//创建了一个线程对象，传入一个线程函数，新线程就开始运行了
	thread t1(threadHandle1);
	//主线程等待子线程结束，主线程继续往下运行
	//t1.join();
	t1.detach();

	cout << "main run over!" << endl;
	return 0;
}

3.线程间互斥

mutex

只能用在简单的临界区代码段的互斥操作中

多线程程序
竞态条件:多线程程序执行的结果是一致的，不会随着CPU对线程不同的调用顺序，而产生不同的运行结果，

#include<thread>
#include<list>
#include<mutex>
using namespace std;


static int ticketcount = 100;
std::mutex mtx;//全局的一把互斥锁

//模拟买票的线程函数
void sellTicket(int index)
{
	mtx.lock();//此种加锁相当于只有一个窗口在买票
	while (ticketcount >= 1)//锁+双重判断
	{
		if (ticketcount > 0)
		{
			//临界区代码段-》原子操作=》线程间互斥操作了=》mutex
			cout << "窗口：" << index << "  卖出第：" << ticketcount << " 张票！" << endl;
				ticketcount--;
			
		}
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
	mtx.unlock();
}
int main()
{
	list<std::thread>tlist;
	for (int i = 1; i <= 3; i++)
	{
		tlist.push_back(std::thread(sellTicket, i));
	}

	for (thread& t : tlist)
	{
		t.join();
	}
	cout << "所有窗口买票结束！" << endl;
	return 0;
}

#include<thread>
#include<list>
#include<mutex>
using namespace std;


static int ticketcount = 100;
std::mutex mtx;//全局的一把互斥锁

//模拟买票的线程函数
void sellTicket(int index)
{
	while (ticketcount >= 1)//锁+双重判断
	{
		mtx.lock();
		if (ticketcount > 0)
		{
			//临界区代码段-》原子操作=》线程间互斥操作了=》mutex
			cout << "窗口：" << index << "  卖出第：" << ticketcount << " 张票！" << endl;
				ticketcount--;
		}
		mtx.unlock();
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}

lock_quard

mutex最好不要手动加锁和解锁。因为临界区代码一旦执行错误，或者return了，那么获取的锁就无法释放了，一个线程不释放锁，其他线程不能获取锁，所以整个进程就是死锁，所以需要采取智能指针的思想（栈上对象出作用域都会被析构）：lock_quard / unique_lock
保证了所有线程都能释放锁，有效防止了死锁问题的发生

缺点：delete了赋值和拷贝构造，所以不可能用在函数参数传递或者返回过程中

static int ticketcount = 100;
std::mutex mtx;//全局的一把互斥锁

//模拟买票的线程函数
void sellTicket(int index)
{
	while (ticketcount >= 1)//锁+双重判断
	{
		{
			lock_guard<mutex>lock(mtx);
			if (ticketcount > 0)
			{
				//临界区代码段-》原子操作=》线程间互斥操作了=》mutex
				cout << "窗口：" << index << "  卖出第：" << ticketcount << " 张票！" << endl;
				ticketcount--;
			}
		}
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	
	}
}

unique_lock

提供了右值的赋值重载和右值拷贝构造，所以具有资源转移的功能，可以使用在函数调用过程中

在函数调用，参数传递过程中不能使用lock_quard，因为lock_quard不支持赋值和拷贝构造，此时就需要使用unique_lock

void sellTicket(int index)
{
	while (ticketcount >= 1)//锁+双重判断
	{
		unique_lock<std::mutex>lock(mtx);
		if (ticketcount > 0)
		{
			//临界区代码段-》原子操作=》线程间互斥操作了=》mutex
			cout << "窗口：" << index << "  卖出第：" << ticketcount << " 张票！" << endl;
			ticketcount--;
		}
		lock.unlock();
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}

4.线程间同步通信机制

生产者—消费者模型：锁+条件变量

#include<iostream>
#include<thread>
#include<list>
#include<mutex>
#include<queue>//C++STL所有的容器都不是线程安全
#include<condition_variable>
using namespace std;

std::mutex mtx;//定义互斥锁，做线程间的互斥操作
std::condition_variable cv; //定义条件变量，做线程间的同步通信操作

//生产者生产一个物品，通知消费者消费一个;消费完了，消费者再通知生产者继续生产物品
class Queue
{
public:
	void put(int val)//生产物品
	{
		//lock_guard<mutex>lock(mtx);
		unique_lock<std::mutex>lck(mtx);
		while (!que.empty())
		{
			//que不空，生产者应该通知消费者消费，消费完了再继续消费
			//生产者进程应该1.进入阻塞状态，2.并且释放mtx,消费者可以获得锁
			
			cv.wait(lck);//通过条件变量wait进入等待状态，一进入等待状态就会把锁释放
		}
		que.push(val);
		cv.notify_all();//通知其它所有的线程，我生产了一个物品，你们赶紧消费吧
		//其它线程得到该通知，就会从等待状态=》阻塞状态=》获取互斥锁才能继续执行

		cout << "生产者 生产：" << val << " 号物品" << endl;
	}
	int get()//消费物品
	{
		//lock_guard<mutex>lock(mtx);
		unique_lock<std::mutex>lck(mtx);
		while (que.empty())
		{
			//que空，消费者应该通知生产者生产
			//进程应该1.进入阻塞状态，2.并且释放mtx
			
			cv.wait(lck);//通过条件变量wait进入等待状态，一进入等待状态就会把锁释放
		}
		int val = que.front();
		que.pop();
		cv.notify_all();//通知其它线程我消费完了，赶紧生产吧

		cout << "消费者 消费：" << val << " 号物品" << endl;
		return val;
	}
private:
	queue<int>que;
};

void producer(Queue* que)
{
	for (int i = 1; i <= 10; i++)
	{
		que->put(i);
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}
void consumer(Queue* que)
{
	for (int i = 1; i <= 10; i++)
	{
		que->get();
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}

int main()
{
	Queue que;
	thread t1(producer,&que);
	thread t2(consumer, &que);

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

	return 0;
}