多线程根据不同的平台要求有所不同，自C++11之后，语言层面提供了原生的、跨平台的多线程工具
Windows：使用Visual Studio即可，无需设置
Linux：在编译的时候加上选项 -lpthread

附加：把一个线程附加到主线程(等它结束)
抛弃：放弃一个线程的所属权
一定要在和线程相关联的std::thread销毁前，执行附加或抛弃

因为多个线程之间一般需要协调进度，所以可能需要等待
一般是用信号量

保护一块内存区域，注意逻辑要防止死锁

#include<mutex>
 
int main()
{
    std::mutex LockForSomething;
 
    LockForSomething.lock();
 
    //Safe Place to Do Some Change
 
    LockForSomething.unlock();
 
    return 0;
}

原子类型的变量可以被保护，不会产生多个线程同时访问的冲突

#include<atomic>
#include<cstdio>
 
//声明一个原子类型的int
//对它的操作都是原子的，不会被打断
std::atomic<int> Count;
 
int main()
{
    //赋值、运算、比较这些重载了的都是正常的
    Count=0;
    Count=Count+10;
    if(Count>0);
 
    //输出
    int _x;printf("%d\n",_x=Count);
 
    return 0;
}

#include<algorithm>
#include<thread>
#include<cstdio>
 
//For Work
void SayHello(int x)
{
    for (int i = 1; i <= x; i += 1)
    {
        printf("[%02d] Hello\n", i);
    }
}
 
int main()
{
    using std::thread;
 
    auto p_thread = new thread(SayHello, 10);
 
    if (p_thread->joinable())
    {
        p_thread->join();
        //p_thread->detach();
    }
 
    delete p_thread;
 
    return 0;
}

condition_variable

以下的信号量就是基于条件变量实现的
信号量手动实现

#pragma once
 
#include <mutex>
#include <condition_variable>
 
class Semaphore
{
private:
    std::mutex mutex;
    std::condition_variable cv;
    int count;
 
public:
    explicit Semaphore(int count = 0) : count(count) {}
 
public:
    void Signal()
    {
        std::unique_lock<std::mutex> lock(mutex);
        ++count;
        cv.notify_one();
    }
 
    void Wait()
    {
        std::unique_lock<std::mutex> lock(mutex);
        cv.wait(lock, [=] { return count > 0; });
        --count;
    }
};