https://www.runoob.com/cplusplus/cpp-multithreading.html

两种类型的多任务处理：基于进程和基于线程。

基于进程的多任务处理是程序的并发执行。
基于线程的多任务处理是同一程序的片段的并发执行。

线程

c++11以后有了 标准库

1 函数
2 类成员函数
3 lambda函数
4 仿函数
https://www.jianshu.com/p/99f2bdd427ba
仿函数是定义了一个含有operator()成员函数的对象，可以视为一个一般的函数，只不过这个函数功能是在一个类中的运算符operator()中实现，是一个函数对象，它将函数作为参数传递的方式来使用。

https://blog.csdn.net/toby54king/article/details/105103111

5 类的静态成员函数
因为静态 函数 不与类的任何对象相关联。 因此，我们可以直接将类的 静态成员函数 作为 线程函数 传递，而无需传递任何指向对象的指针。

thread t5(mythread2::func,3,"xxx"); 书写的时候加上类名

6 类的普通成员函数
必须先创建类的对象，必须保证对象的生命周期比子线程要长，
因为类的普通成员函数可能访问类的普通成员变量，如果对象销毁了，可能发生内存泄漏

mythread3 myth;
thread t6(&mythread3::func,&myth,3,"xccccc");
第一个参数填成员函数的地址
第二个参数填对象的地址，也就是this指针
后面才是成员函数的对象参数

https://baike.baidu.com/item/%E7%BA%BF%E7%A8%8B/103101

C++ 11 线程
C++ 11 线程的头文件是。
创建线程std::thread::thread(Function&& f, Args&&... args); [3] 
等待线程结束std::thread::join(); [3] 
脱离线程控制std::thread::detach(); [3] 
交换线程std::thread::swap( thread& other ); [3] 

https://www.bilibili.com/video/BV198411e76j/?spm_id_from=333.337.search-card.all.click&vd_source=e7d12c9f66ab8294c87125a95510dac9

#include<thread>

1 如何创建线程

main函数中的程序为主程序，又叫主线程
对象thread 中的为子线程
主线程只有一个，子线程与硬件资源有关，硬件越好，就可以创建越多的子线程

仿函数的方式创建一个类在类里面重载 operator（）然后
thread t4(mythread1(),3,"woshiyizhishashaniao");

删除拷贝构造

不允许线程对象之间的拷贝

转移之后原来的线程对象不再代表线程

回收线程的资源

先创建的不一定跑的快
线程的任务函数返回后子线程将会终止
如果主程序推出，子程序全部终止

demo程序复制到linux中
头文件修改
unistd.h
sleep也需要修改

join（）函数 等待子程序退出，回收资源，如果已退出就立即返回
detach（） 主程序不能退出
joinable（）返回布偶类型

this thread

call once

想要只执行一次的函数
可以放在主函数中
但是有时需要放在线程函数中
这个时候可以考虑


call once 第一个参数 锁 ，函数名， 参数

这里提到可以自己手动设置一个flag 置1或者置0
用if语句进行调用，这样是不行的

native handle

不同系统 线程库不同

linux的 pthread 线程库文件
编译过程中
g++ -0 demo01 demo01.cpp -std=c++11 -lpthread
https://www.runoob.com/w3cnote/gcc-parameter-detail.html

在子线程运行时想要终止他
linux的线程库拥有该功能
man pthread_cancel
这里的线程id和c11的不是同一个东西，c11的thread类没有这个东西

线程安全

共享进程资源

一个房间5个人住只有一个厕所

全部线程共享cout对象，容易造成输出紊乱

全局变量aa 两个子线程都分别加上100次
出现的aa随机，无法确定 不是200

顺序性 可见性 原子性

三个步骤并非一次性执行完，例如自己的cpu时间片用完了，就会被操作系统切换出去，到线程再次获得时间片时，黄花菜都凉快了
理解为来不及了
上述提到的 全局变量aa 如果是原子操作 那么得到的结果就是 200了

保证内存变量的可见性，禁止代码优化 重排序
关键字修饰变量 无法解决问题，只解决了线程可见性问题
电脑是多核的
但是在单核的情况下结果是正确的 （没用到关键字）

互斥锁

在使用cout资源时 申请加锁 ，这个线程加了锁，就只有这个线程能用了，别的线程得等待，直到这个线程把锁给解锁了，别的线程才能加锁。
但是他视频中所有线程都是公用这一个函数

trylock（） 应用场景为公共厕所有多个 一个满了直接找另一个 不需要等待
未锁定状态 就加锁成功 返回 true
锁定状态就是 加锁失败 返回false 不会阻塞等待

time_mutex
bool try_lock_for(时间长度) 如果等待时间太长 就放弃
bool try_lock_until(时间点)

recursive_mutex类

递归互斥锁 允许同一线程多次获得互斥锁，可以解决同一线程多次加锁造成的死锁问题

例如 函数1 中有加锁和解锁
函数2中也有加锁和解锁，函数2中调用了函数1

调用函数2 报错 原因是 出现了死锁。
函数2持有锁，再去调用函数1，发现函数1不可能申请到锁，就出现了死锁。
如果把普通锁改为递归锁就不会报错

lock guard类

条件变量 生产 消费者模型

给代码加上一个作用域， 处理的时候不需要占用锁的资源

字符变量message应该定义在作用域的外面

用aa的outcache 成员函数创建三个消费者线程

6 类的普通成员函数

消费者线程创建了就一直存在，不会退出
并且 incache成员函数只用于生产数据，生产完数据函数就返回了。

代码

原本认为只有唤醒一个线程
等待队列
也可以唤醒所有线程

所有线程竞争队列中的数据
条件变量wait一般放在消费者
unique lock 可以手动解锁，从而消除作用域

申请加锁， 只有一个线程阻塞在等待唤醒者信号 其余都阻塞在等待加锁的地方

虚假唤醒

原子类型

互斥锁代价比较高