1.为什么要用多线程
任务分解：
耗时的操作，任务分解，实时响应
数据分解：
充分利用多核CPU处理数据
数据流分解：
读写分流，解耦合设计
2.并发，进程，线程的基本概念
2.1 并发：两个或者两个以上的独立任务同时进行：一个程序同时执行多个独立的任务；
对于单核计算机来说，某一时刻只能执行一个任务：由操作系统调度，每秒钟进行多次的所谓的“任务切换”，对每个任务设置一个执行时间，到了时间之后切换到另一个任务，就这样来回切换，来实现并发，这种叫并发假象，也就是所谓的“上下文切换”。这种切换时间花销很大。
对于多核计算机来说，可真正实行并发任务，但一般情况下，多核处理器的也需要进行来回切换，因为任务一般可达到好几千个，而处理器一般就是2核，4核，6核，8核等。
2.2 进程：运行起来的可执行程序。（在任务管理器->用户中可以看到）
2.3 线程：用来执行代码的
- 每个进程中只有一个主线程。
- 当执行一个可执行文件时，这个主线程就自动启动了，相当于是主线程来执行该代码，主线程与进程有你有我，无我无你。
除了主线程之外，还可以自己写代码来创建其他线程，及多线程（并发）每个线程都需要一个独立的堆栈空间(1M)， 不宜太多。不然来回切换会耗费程序运行的时间。
3.并发的实现：
- 多进程实现
- 多线程实现（自己写代码实现）
多进程并发：
word启动后就是进程，浏览器启动后就是进程。账号服务器启动就是一个进程，游戏逻辑服务器启动后又是一个进程，就叫多进程。进程与进程之间的通讯：在一台电脑上通讯手段有：管道，文件，消息队列，共享内存等；不在同一台电脑上的通信手段：socket通信技术。
多线程并发：
在单个进程中创建多个线程，线程可以看作是轻量级的进程，一个进程中的所有线程共享内存，使用多线程开销远远小于多进程；但共享内存一般会带来数据一致性问题，比如两个线程同时传递数据时会引起混乱，所以在写线程时要注意先后。传统情况下：主线程结束，子线程必须结束掉，不然就是不合格的程序，一般都应该是主线程等子线程，再自己执行。但在C++11新标准下不用，如detach()的使用。
4.创建线程
C++11新标准线程库
创建线程函数：windows下：CreateThread(),_beginthted(),_beginthredexe()
POSIX thread(pthread)库:配置后可跨平台使用；
C++11新标准支持跨平台使用。
一般情况下也可用thread创建线程，但需要引入thread库
主线程从main()函数开始，那么自己写的线程应该也从一个函数开始运行(初始函数)
新标准下detach()函数：
主线程不再与子线程汇合，主线程可以先结束，不用等待子线程，但不建议经常使用。因为当主线程运行完后，子线程很有可能执行不完。
windows运行thread时，一定要配置好mingw.
官网地址：MinGW-w64 - for 32 and 64 bit Windows - Browse Files at SourceForge.net
https://sourceforge.net/projects/mingw-w64/files/①点击File
②下载离线包，因为在线安装的话很慢很慢
x86_64是64位的，想要运行多线程就必须选择posix，所以我选择的是第二个，直接下载解压即可
③配置环境变量
此电脑---属性---高级系统设置---环境变量---设置系统变量---双击Path将mingw64下的bin路径粘贴复制到Path处，点击确定即就配置好了。
范例演示：
#include <iostream>
#include <thread>
using namespace std;
void myPrint()
{
cout << "我的线程开始运行" << endl;
//-------------
//-------------
cout << "我的线程运行完毕" << endl;
}
int main()
{
//(1)创建了线程，线程执行起点（myPrint）是myPrint；(2)执行线程
thread myThread(myPrint);//thread标准库中的一个类，用来创建线程
myThread.join();//阻塞主线程，让主线程等待子线程完成执行，然后子线程与主线程汇合，主线程继续
if (myThread.joinable())
{
cout << "可以调用可以调用join()或者detach()" << endl;
}
else
{
cout << "不能调用可以调用join()或者detach()" << endl;
}
cout << "Hello World!" << endl;
system("pause");
return 0;
}5.其他创建线程手法：
类对象范例演示：
#include <iostream>
#include <thread>
using namespace std;
class Ta
{
public:
void operator()()
{
cout << "我的线程开始运行" << endl;
//-------------
//-------------
cout << "我的线程运行完毕" << endl;
}
};
int main()
{
// main函数里的：
Ta ta;
thread myThread(ta);
myThread.join();
cout << "Hello World!" << endl;
system("pause");
return 0;
}用lambda表达式创建线程:
范例演示：
#include <iostream>
#include <thread>
using namespace std;
int main()
{
auto lambdathread = []
{
cout << "线程开始" << endl;
//...
cout << "线程结束" << endl;
};
thread myThread(lambdathread);
myThread.join();
cout << "Hello World!" << endl;
system("pause");
return 0;
}6.传递临时对象作线程参数
6.1 陷阱1范例展示：
#include <iostream>
#include <thread>
using namespace std;
void myPrint(const int &i, char* pmybuf)
{
//如果线程从主线程detach了
//i不是mvar真正的引用，实际上值传递，即使主线程运行完毕了，子线程用i仍然是安全的，但仍不推荐传递引用
//推荐改为const int i
cout << i << endl;
//pmybuf还是指向原来的字符串，所以这么写是不安全的
cout << pmybuf << endl;
}
int main()
{
int mvar = 1;
int& mvary = mvar;
char mybuf[] = "this is a test";
thread myThread(myPrint, mvar, mybuf);//第一个参数是函数名，后两个参数是函数的参数
//myThread.join();
myThread.detach();
cout << "Hello World!" << endl;
}
//引用和指针慎用6.2 陷阱2范例展示：
#include <iostream>
#include <thread>
#include <string>
using namespace std;
void myPrint(const int i, const string& pmybuf)
{
cout << i << endl;
cout << pmybuf << endl;
}
int main()
{
int mvar = 1;
int& mvary = mvar;
char mybuf[] = "this is a test";
//如果detach了，这样仍然是不安全的
//因为存在主线程运行完了，mybuf被回收了，系统采用mybuf隐式类型转换成string
//推荐先创建一个临时对象thread myThread(myPrint, mvar, string(mybuf));就绝对安全了。。。。
thread myThread(myPrint, mvar, mybuf);
//myThread.join();
myThread.detach();
cout << "Hello World!" << endl;
}
6.3 正确演示：
#include <iostream>
#include <thread>
using namespace std;
void myPrint(const int i, const string pmybuf)
{
cout << i << endl;
cout << pmybuf << endl;
}
int main()
{
int mvar = 1; //用来测试对比
int &mvary = mvar;
char mybuf[] = "Bid farewell to the epidemic!";
thread myThread(myPrint, mvar, string(mybuf)); //string(mybuf)临时对象，为避免隐式类型转换
//myThread.join();
myThread.detach();
system("pause");
return 0;
}
//类对象同理，创建临时对象就可以解决这种问题，须注意的地方是要传递引用结论：
建议不使用detach()，只使用join(),这样就不存在局部变量失效导致线程对内存的非法引用问题。
7. 临时对象作为线程参数深入：
线程ID：id是个数字，每个线程对应一个数字，每个线程对应的线程数字不同，可用c++标准库的函数来获取，this_thread::get_id()。
#include <iostream>
#include <thread>
using namespace std;
class A
{
public:
int m_i;
A(int i) : m_i(i) { cout << "构造函数 " << std::this_thread::get_id() << endl; }
A(const A &i) : m_i(i.m_i) { cout << "复制构造函数 " << std::this_thread::get_id() << endl; }
~A(int i) : m_i(i) { cout << "析构函数 " << std::this_thread::get_id() << endl; }
};
void myPrint(const A &pmybuf)
{
pmybuf.m_i = 199;
cout << "子线程myPrint的参数地址是" << &pmybuf << "thread = " << std::this_thread::get_id() << endl;
}
int main()
{
int mm=10;
// myPrint(const A& pmybuf)中引用不能去掉，如果去掉会多创建一个对象
// const也不能去掉，去掉会出错
//即使是传递的const引用，但在子线程中还是会调用拷贝构造函数构造一个新的对象，
//所以在子线程中修改m_i的值不会影响到主线程
//如果希望子线程中修改m_i的值影响到主线程，可以用thread myThread(myPrint, std::ref(myObj));
//这样const就是真的引用了，myPrint定义中的const就可以去掉了，类A定义中的mutable也可以去掉了
thread myThread(myPrint, A(mm));
myThread.join();
// myThread.detach();
cout << "Hello World!" << endl;
system("pause");
return 0;
}
#include <iostream>
#include <thread>
#include <memory>
using namespace std;
//创建一个智能指针
void myPrint(unique_ptr<int> pp)
{
cout << "thread = " << std::this_thread::get_id() << endl;
}
int main()
{
unique_ptr<int> up(new int(10));
//独占式指针只能通过std::move()才可以传递给另一个指针
//传递后up就指向空，新的pp指向原来的内存
//所以这时就不能用detach了，因为如果主线程先执行完，pp指向的对象就被释放了
thread myThread(myPrint, std::move(up));
myThread.join();
//myThread.detach();
return 0;
}
8. 多线程数据共享：
涉及互斥量，锁等概念
8.1 互斥量（mutex）的基本概念
- 互斥量就是个类对象，可以理解为一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁定成功，如果没有锁成功，那么流程将卡在lock()这里不断尝试去锁定。
- 互斥量使用要小心，保护数据不多也不少，少了达不到效果，多了影响效率。
8.2 互斥量的用法
- 包含#include <mutex>头文件
- 1. 成员函数：lock()，unlock()
- 步骤：1.lock()，2.操作共享数据，3.unlock()。
- lock()和unlock()要成对使用
- 2. lock_guard类模板
- lock_guard<mutex> sbguard(myMutex);可直接取代lock()和unlock()
- lock_guard构造函数执行了mutex::lock();在作用域结束时，调用析构函数，执行mutex::unlock()，但不如lock()和unlock()灵活
8.3 死锁
A一直在北京死等B，B一直在深圳死等A，那么A，B永远见不了面，就叫死锁。
1 死锁演示
死锁至少有两个互斥量mutex1，mutex2。
- a.线程A执行时，这个线程先锁mutex1，并且锁成功了，然后去锁mutex2的时候，出现了上下文切换。
- b.上下文切换后线程B执行，这个线程先锁mutex2，因为mutex2没有被锁，即mutex2可以被锁成功，然后线程B要去锁mutex1.
- c.此时，死锁产生了，A锁着mutex1，需要锁mutex2，B锁着mutex2，需要锁mutex1，两个线程没办法继续运行下去。
2 死锁的一般解决方案：
只要保证多个互斥量上锁的顺序一样就不会造成死锁。3 std::lock()函数模板
std::lock(mutex1,mutex2……); 同时锁定多个互斥量(这种情况很少见)，用于处理多个互斥量。如果互斥量中一个没锁住，它就卡着了，等所有互斥量都锁住，才能继续执行。如果有一个没锁住，就会把已经锁住的释放掉（要么互斥量都锁住，要么都没锁住，防止死锁），别忘了unlock()。
4 std::lock_guard的std::adopt_lock参数std::lock_guardstd::mutex my_guard(my_mutex,std::adopt_lock);
加入adopt_lock后，在调用lock_guard的构造函数时，不再进行lock();
adopt_guard为结构体对象，起一个标记作用，表示这个互斥量已经lock()，不需要再lock()。
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
void inMsgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
cout << "11111111111111111111111111111" << i << endl;
{
// lock_guard<mutex> sbguard(myMutex1, adopt_lock);
lock(myMutex1, myMutex2);
// myMutex2.lock();
// myMutex1.lock();
msgRecvQueue.push_back(i);
myMutex1.unlock();
myMutex2.unlock();
}
}
}
bool outMsgLULProc()
{
myMutex1.lock();
myMutex2.lock();
if (!msgRecvQueue.empty())
{
cout << "000000000000000000000000000000" << msgRecvQueue.front() << endl;
msgRecvQueue.pop_front();
myMutex2.unlock();
myMutex1.unlock();
return true;
}
myMutex2.unlock();
myMutex1.unlock();
return false;
}
void outMsgRecvQueue()
{
for (int i = 0; i < 100000; ++i)
{
if (outMsgLULProc())
{
}
else
{
cout << "nnnnnnnnnnnnnnnnnnnnnnnnnnn" << endl;
}
}
}
private:
list<int> msgRecvQueue;
mutex myMutex1;
mutex myMutex2;
};
int main()
{
A myobja;
mutex myMutex;
thread myOutMsgObj(&A::outMsgRecvQueue, &myobja);
thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
myOutMsgObj.join();
myInMsgObj.join();
return 0;
}
9. unique_lock()取代lock_guard()
unique_lock是个类模板，一般推荐使用lock_guard()。
unique_lock比lock_guard灵活很多（多出来很多用法），但效率差一点，占用内存多。
unique_lock<mutex> myUniLock(myMutex);
9.1.unique_lock的第二个参数
9.1.1 std::adopt_lock：
表示这个互斥量已经被lock()，即不需要在构造函数中lock这个互斥量了。
前提：必须提前lock；
lock_guard中也可以用这个参数
9.1.2 std::try_to_lock：
尝试用mutex的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里；
使用try_to_lock的原因是防止其他的线程锁定mutex太长时间，导致本线程一直阻塞在lock这个地方
前提：不能提前lock();
owns_locks()方法判断是否拿到锁，如拿到返回true。
9.1.3 std::defer_lock：
如果没有第二个参数就对mutex进行加锁，加上defer_lock是始化了一个没有加锁的mutex
不给它加锁的目的是以后可以调用unique_lock的一些方法
前提：不能提前lock
9.2.unique_lock的成员函数（前三个与std::defer_lock联合使用）
9.2.1 lock()：加锁。不用自己unlock();
9.2.2 unlock()：解锁。
因为一些非共享代码要处理，可以暂时先unlock()，用其他线程把它们处理了，处理完后再lock()。
9.2.3 try_lock()：尝试给互斥量加锁
如果拿不到锁，返回false，否则返回true。
9.2.4 release()：
myUniLock(myMutex);相当于把myMutex和myUniLock绑定在了一起，release()就是解除绑定，返回它所管理的mutex对象的指针，并释放所有权
lock的代码段越少，执行越快，整个程序的运行效率越高。
a.锁住的代码少，叫做粒度细，执行效率高；
b.锁住的代码多，叫做粒度粗，执行效率低；
内容来源于bilibilic++11并发与多线程视频课程这个视频