线程
线程是操作系统能够进行运算调度的最小单位。被包含在进程之中，是进程的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程可以并发执行多个线程，每个线程会执行不同的任务。对应在现实生活中，进程是组长，线程是小组成员。
怎么创建启动一个线程
在语言级别，一般调用std名称空间的thread类来启动一个线程。
其对应操作系统层次的一下系统调用：
windows： createThread
linux：pthread_create
以下是thread类的一个构造函数：
template <class Fn, class... Args>
explicit thread (Fn&& fn, Args&&... args);
我们可以看到，其需要一个线程函数（也可以是类对象和lambda表达式）以及这个函数所需要传入的参数。
所以我们便可以这样来创建线程：
void threadHandle1(int time)
{
// 让子线程睡眠time秒
std::this_thread::sleep_for(std::chrono::seconds(time));
cout << "hello thread1!" << endl;
}
void threadHandle2(int time)
{
// 让子线程睡眠time秒
std::this_thread::sleep_for(std::chrono::seconds(time));
cout << "hello thread2!" << endl;
}
// 创建了一个线程对象,传入一个线程函数,新线程就开始运行了
std::thread t1(threadHandle1, 2);
std::thread t2(threadHandle2, 3);
这样，t1就会执行threadHandle1函数，t2执行threadHandle2函数。
线程如何区分
线程除了站在我们角度上的以名字区分，它还有一个属于自己的id！
通过std::thread::get_id()便可以获取到该成员对象线程的id。
std::cout << "t1 thread :: ID = " << t1.get_id() << std::endl;
而在线程函数中通过std::this_thread::get_id()获取线程id。
std::cout << "inside thread :: ID = " << std::this_thread::get_id() << std::endl;
线程如何结束
线程结束主要分为以下四种方式：
线程函数返回（推荐）
调用ExitThraed函数，线程自行撤销
同一进程或者另一个进程中调用TerminateThread函数
ExitProcess和TerminateProcess函数也可以用来终止线程进行
除了第一种，其他都不推荐使用，那我就不把它们写进博客了。
主线程如何处理子线程
主要用到的就是join和detach，其他的百度去吧。
t1.join();
这个方法让主函数等待子线程结束，主线程才继续往下继续运行。
t1.detach();
这个方法把子线程设置为分离线程。也就是主线程和子线程断绝父子关系了。
在一般情况下，如果主线程结束，就代表整个进程结束，如果这时有子线程还未结束就会出现运行错误。
当设置子线程为分离线程，主线程结束，子线程也自动结束。
多线程编程
总结了线程的基本知识，我们现在就来看一下多线程编程。
假设有车站的三个买票窗口来卖100张票。
int ticketCount = 100; // 车站有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;
}
现在我们看看具体是怎样卖票的：
我们知道对车票（count）进行卖（--操作）时，会分为3步：
mov eax， count
sub eax，1
mov count，eax
这不是原子性的！
CPU可能刚执行完sub操作的时候，该线程（t1）时间片到了执行到其他线程（t2），这样其他卖票窗口拿到的count也是100，然后这个线程（t2）执行完count = 99，CPU又回去执行t1，这时你就会白给一张票。
所以就必须引入锁操作。
锁
在多线程程序，需满足竞态条件：多线程程序执行的结果是一致的，不会随着CPU对线程不同的调用顺序，而产生不同的结果。
所以我们就需要定义一把锁。
std::mutex mtx; // 全局的一把互斥锁
有了这把锁，我们就可以实现一个没什么大错的卖票程序了：
// 模拟卖票的线程函数 lock_guard unique_lock
void sellTicket(int index)
{
while (ticketCount > 0) // ticketCount=1 锁+双重判断
{
// 保证所有线程都能释放锁，防止死锁问题的发生 scoped_ptr
lock_guard<std::mutex> lock(mtx);
if (ticketCount > 0)
{
// 临界区代码段 =》 原子操作 =》 线程间互斥操作了 =》 mutex
cout << "窗口:" << index << "卖出第:" << ticketCount << "张票!" << endl;
//cout << ticketCount << endl;
ticketCount--;
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
这里用了lock_guard<std::mutex> lock(mtx); 把锁包装成了一个类，保证能出函数一定会释放锁。
CAS原子操作
因为锁的操作是比较重，而且在临界区代码做的事情比较复杂，比较多。所以引入了CAS来保证上面的--操作的原子特性。同时这也是无锁操作。
首先定义一下原子的类型：
volatile std::atomic_bool isReady = false;
volatile std::atomic_int mycount = 0;
这里的volatile保证了每次数据都是从内存拿，而不是有一定安全性风险的寄存器。
void task()
{
while (!isReady)
{
std::this_thread::yield(); // 线程出让当前的CPU时间片，等待下一次调度
}
for (int i = 0; i < 100; ++i)
{
mycount++;
}
}
int main()
{
list<std::thread> tlist;
for (int i = 0; i < 10; ++i)
{
tlist.push_back(std::thread(task));
}
std::this_thread::sleep_for(std::chrono::seconds(3));
isReady = true;
for (std::thread &t : tlist)
{
t.join();
}
cout << "mycount:" << mycount << endl;
return 0;
}
这明显就比锁轻便了很多！
lock_guard和unique_lock
这两个其实可以类比智能指针来记：
lock_gurad类比于scoped_ptr，它的拷贝构造和复制构造都被删除了，不可用在函数参数传递或者返回过程中，只能用在简单的临界区代码段的互斥操作中。
lock_ guard(const lock_ guard&)=delete;
lock_ guard& operator= (const lock_ guard&)=delete;
而unique_lock可以类比于unique_ptr，它不仅可以用在简单的临界代码段的互斥操作中，还能用在函数调用过程中。
总的来说，建议使用unique_lock.
线程通信——生产者消费者模型
现在就用一个比较常用的模型来认识一下线程通信。
首先先定义一下互斥锁mtx和条件变量cv：
std::mutex mtx; // 定义互斥锁，做线程间的互斥操作
std::condition_variable cv; // 定义条件变量，做线程间的同步通信操作
然后定义出生产者和消费者的类queue：
// 生产者生产一个物品，通知消费者消费一个；消费完了，消费者再通知生产者继续生产物品
class Queue
{
public:
void put(int val) // 生产物品
{
//lock_guard<std::mutex> guard(mtx); // scoped_ptr
unique_lock<std::mutex> lck(mtx); // unique_ptr
while (!que.empty())
{
// que不为空，生产者应该通知消费者去消费，消费完了，再继续生产
// 生产者线程进入#1等待状态，并且#2把mtx互斥锁释放掉
cv.wait(lck); // lck.lock() lck.unlock
}
que.push(val);
/*
notify_one:通知另外的一个线程的
notify_all:通知其它所有线程的
通知其它所有的线程，我生产了一个物品，你们赶紧消费吧
其它线程得到该通知，就会从等待状态 =》 阻塞状态 =》 获取互斥锁才能继续执行
*/
cv.notify_all();
cout << "生产者 生产:" << val << "号物品" << endl;
}
int get() // 消费物品
{
//lock_guard<std::mutex> guard(mtx); // scoped_ptr
unique_lock<std::mutex> lck(mtx); // unique_ptr
while (que.empty())
{
// 消费者线程发现que是空的，通知生产者线程先生产物品
// #1 进入等待状态 # 把互斥锁mutex释放
cv.wait(lck);
}
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; // 两个线程共享的队列
std::thread t1(producer, &que);
std::thread t2(consumer, &que);
t1.join();
t2.join();
return 0;
}
参考文献
[1] 施磊．腾讯课堂——C++高级．图论科技，2020.7．
[2] DoubleLi．如何终止线程运行．博客园，2012.8．15.
转载：https://blog.csdn.net/shenmingxueIT/article/details/107636291