545-C++多线程编程 – 源码巴士

C++语言级别的多线程编程=》代码可以跨平台 windows/linux/mac

C++多线程介绍

thread(线程类)
mutex(互斥锁)
condition_variable(线程间的通信，条件变量)

智能锁：
lock_guard
unique_lock

atomic 原子类型 基于CAS操作的原子类型 线程安全的

sleep_for(睡眠)

C++语言层面 thread（底层用的还是下面平台的方法） 
   windows        linux  strace ./a.out（程序启动的跟踪打印的命令）
      |             |
createThread    pthread_create

可以通过编译器的编译，加个宏，识别当前的操作系统来适配通过语言层面编写thread底层自动调用相应的函数。底层还是调用系统创建的API，只是语言层面加个封装，让用户更加方便使用。

多线程编程

线程内容：
一. 怎么创建启动一个线程
std::thread定义一个线程对象，传入线程所需要的线程函数和参数，
线程自动开启

二. 子线程如何结束
子线程函数运行完成，线程就结束了

三. 主线程如何处理子线程
t.join() : 等待t线程结束，当前线程继续往下运行
t.detach() : 把t线程设置为分离线程，主线程结束，整个进程结束，所有子线程都自动结束了！

代码示例：

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

void threadHandle1(int time)
{
	//让子线程睡眠time秒
	std::this_thread::sleep_for(std::chrono::seconds(time));
	cout << "hello thread1!" << endl;
}
void threadHandle2(int time)
{
	//让子线程睡眠time秒ace this_thread是namespace 
	std::this_thread::sleep_for(std::chrono::seconds(time));
	cout << "hello thread2!" << endl;
}
int main()
{
	//创建了一个线程对象,传入一个线程函数(作为线程入口函数),
	//新线程就开始运行了，没有先后顺序，随着CPU的调度算法执行 
	std::thread t1(threadHandle1, 2);
	std::thread t2(threadHandle2, 3);

	//主线程(main)运行到这里，等待子线程结束，主线程才继续往下运行
	t1.join();
	t2.join();

	//把子线程设置为分离线程，子线程和主线程就毫无关系了
	//主线程结束的时候查看其他线程
	//但是这个子线程运行完还是没运行完都和这个主线程没关系了
	//这个子线程就从这个main分离出去了
	//运行程序时也看不到这个子线程的任何输出打印了
    //t1.detach();

	cout << "main thread done!" << endl;

	//主线程运行完成，查看如果当前进程还有未运行完成的子线程
	//进程就会异常终止
	return 0;
}

在这里插入图片描述
正常情况下，线程执行，在主线程中，必须等待子线程结束，主线程进行往下执行，主线程运行完了，不能存在正在运行还未结束的其他子线程
此时整个进程就要抛异常出错了异常中止了

在linux中，主线程结束，子线程会自动结束的
但是在语言级别，对子线程运行的控制比较严格
我们也可以这么解决：


	//把子线程设置为分离线程，子线程和主线程就毫无关系了
	//主线程结束的时候查看其他线程
	//但是这个子线程运行完还是没运行完都和这个主线程没关系了
	//这个子线程就从这个main分离出去了
	//运行程序时也看不到这个子线程的任何输出打印了
    t1.detach();

线程间互斥

模拟车站三个窗口卖票的程序

线程间的互斥 =》互斥锁mutex =》 lock_guard封装mutex（利用栈上的对象出作用域自动析构，保证所有线程都可以释放锁，防止死锁问题的发生）

多线程程序
竞态条件：多线程程序执行的结果是一致的，
不会随着CPU对线程不同的调用顺序，而产生不同的运行结果（存在竞态条件）。
在这里插入图片描述
每个线程在1个指令周期之内是要保证完成的，但是在多个指令完全由CPU的调度决定的，线程在运行完每个指令的时候，都有可能CPU的时间片到了，线程阻塞住。等待下一轮我们再轮到这个线程执行，才能把剩余的时间片给到这个线程，线程继续执行下面的指令。两个线程可能减完的值是相同的，然后把相同的值写回去了
所以，我们要保证这个操作线程安全！！！每次只有1个线程去做减减操作

使用lock_guard：

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

int ticketCount = 100;//车站有100张车票，由三个窗口一起卖票
std::mutex mtx;//全局的一把互斥锁

//模拟卖票的线程函数  
//lock_guard（拷贝构造和赋值函数删除掉）
//unique_lock（可以转移指针，只有带右值引用的拷贝构造和赋值） 
void sellTicket(int index)
{
	while (ticketCount > 0)//特殊情况：ticketCount=1  所以要进行 锁+双重判断
	{
		//方法1：mtx.lock();
		{
			//保证所有线程都能释放锁，防止死锁问题的发生 scoped_ptr（拷贝构造和赋值函数删除掉）
			lock_guard<std::mutex> lock(mtx);//方法2：智能指针的思想，出作用域就自动析构，释放锁 
			if (ticketCount > 0)
			{
				//临界区代码段  =》 原子操作 =》 线程间互斥操作了 =》 mutex
				cout << "窗口:" << index << "卖出第:" << ticketCount << "张票!" << endl;
				//cout << ticketCount << endl;
				ticketCount--;
			} 
		}
		//方法1：mtx.unlock();
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
}

int main()
{
	list<std::thread> tlist;
	for (int i = 1; i <= 3; ++i)
	{
		tlist.push_back(std::thread(sellTicket, i));
	}

	for (std::thread &t : tlist)
	{
		t.join();
	}

	cout << "所有窗口卖票结束!" << endl;

	return 0;
}