创建线程的函数，头文件thread。参数可以是函数名、仿函数、lambda表达式、类等等。
等待子线程执行完毕
子线程和子进程的死亡是有些区别的。主进程执行完成后，如果子进程没有执行完会被系统init托管；主线程执行完后，如果子线程还没有执行完，子线程会被强制结束。这就有了join函数，等待子线程执行完后在继续执行。
detach守护线程，detach的作用是使主线程结束后，子线程不会强制结束
joinable判断线程是否执行了join或者detach这两个函数，没有调用返回true
线程传递参数注意事项 线程中函数参数 包含#include 头文件
lock()，unlock()
步骤：1.lock()，2.操作共享数据，3.unlock()。
lock()和unlock()要成对使用
2.2 lock_guard类模板
lock_guard sbguard(myMutex);
取代lock()和unlock()
lock_guard构造函数执行了mutex::lock();在作用域结束时，调用析构函数，执行mutex::unlock()
两个线程都已经锁了部分资源，还在互相请求对方已经上锁的资源，都不释放资源，就会造成死锁
解决死锁std::lock()函数模板
std::lock_guard的std::adopt_lock参数
unique_lock比lock_guard灵活很多（多出来很多用法），效率差一点。
unique_lockmyUniLock(myMutex); std::condition_variable实际上是一个类，是一个和条件相关的类，说白了就是等待一个条件达成。
列举一些他的成员函数
wait()线程等待，并且会放下锁
wait(线程名，条件函数（可以省略默认true）)
调用该方法后会进入堵塞状态，需要等待比额的线程调用notify_one（）或者notify_all（）来唤醒，唤醒后会尝试继续拿起释放掉的锁
notify_one()唤醒一个执行过wait还在等待的线程，无法指定唤醒哪一个，是随机唤醒1个
notify_all()唤醒所有执行了wait还在等待的线程
future、saync多线程如果函数有返回值，可以使用这两个去接收返回值
std::future result1 = std::async(mythread);
执行futrue的get方法，就可以获得mythread的返回值，如果函数还没有运行完，那么会进入堵塞，一直到有返回值再继续
futrue的wait就是等待返回值，是一个堵塞的方法。
saync的参数saync有两个参数，第一个参数是如何创建线程，第二个参数是线程函数名字
如果不指定，就是两个随机
std::launch::deferred该参数线程不会直接创建线程，而且等待执行。
当用户调用get方法的时候，才会执行线程。
注意：他不会创建线程，也是在主线程中执行的方法
std::launch::async该参数就是直接创建线程直接。是直接执行的
std::packaged_task类模板，它的模板参数是各种可调用对象，通过packaged_task把各种可调用对象包装起来，方便将来作为线程入口函数来调用。
std::packaged_task
std::thread t1(std::ref(mypt), 1);
并不会直接调用线程，还是需要使用thread去创建显示，他的作用只是打包
可以通过 get_future(); 获取返回值
std::promise类模板我们能够在某个线程中给它赋值，然后我们可以在其他线程中，把这个值取出来
std::promise myprom;
std::thread t1(mythread, std::ref(myprom), 180);
t1.join(); //在这里线程已经执行完了
std::future fu1 = myprom.get_future(); //promise和future绑定，用于获取线程返回值
把他当成一个参数传入，在线程中用setValue来改变他的值，在主线程获取参数
std::async和std::thread()区别：std::thread()如果系统资源紧张可能出现创建线程失败的情况，如果创建线程失败那么程序就可能崩溃，而且不容易拿到函数返回值（不是拿不到）
std::async()创建异步任务。可能创建线程也可能不创建线程，并且容易拿到线程入口函数的返回值；
由于系统资源限制：
①如果用std::thread创建的线程太多，则可能创建失败，系统报告异常，崩溃。
②如果用std::async，一般就不会报异常，因为如果系统资源紧张，无法创建新线程的时候，async不加额外参数的调用方式就不会创建新线程。而是在后续调用get()请求结果时执行在这个调用get()的线程上。
如果你强制async一定要创建新线程就要使用 std::launch::async 标记。承受的代价是，系统资源紧张时可能崩溃。
③根据经验，一个程序中线程数量 不宜超过100~200 。
std::atomic原子类，执行不会被中断
只能使用++ – 或者+=类似的运算符才可以保证原子性
Windows临界区临界区跟上锁类似，有进入临界区，离开临界区，作用和和锁是一样的。
创建临界区CRITICAL_SECTION my_winsec;
初始化临界区InitializeCriticalSection(&my_winsec)
进入临界区EnterCriticalSection(&my_winsec);
是可以重复进入的，mutex是无法重复lock的
离开临界区LeaveCriticalSection(&my_winsec);
手写自动自动离开的临界区class CWinLock {public:
CWinLock(CRITICAL_SECTION *pCritmp)
{my_winsec =pCritmp;
EnterCriticalSection(my_winsec);
}
~CWinLock()
{LeaveCriticalSection(my_winsec)
};
private:
CRITICAL_SECTION *my_winsec;
};std::mutex 独占式互斥量
std::recursive_mutex：允许在同一个线程中同一个互斥量多次被 lock() ，（但是递归加锁的次数是有限制的，太多可能会报异常），效率要比mutex低。
如果你真的用了 recursive_mutex 要考虑代码是否有优化空间，如果能调用一次 lock()就不要调用多次。
带超时的互斥量 std::timed_mutex 和 std::recursive_timed_mutexstd::timed_mutex：是待超时的独占互斥量try_lock_for()：
等待一段时间，如果拿到了锁，或者超时了未拿到锁，就继续执行（有选择执行）
try_lock_until()：
两者的区别就是一个参数是时间段，一个参数是时间点
自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。
获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成busy-waiting。即不断的消耗cpu
它是为实现保护共享资源而提出一种锁机制。其实，自旋锁与互斥锁比较类似，它们都是为了解决对某项资源的互斥使用。无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。但是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，”自旋”一词就是因此而得名。
class CAS
{private:
std::atomicflag;
public:
CAS():flag(false) {}
~CAS() {}
CAS(const CAS& s) = delete;
CAS& operator=(const CAS&) = delete;
void lock()
{bool expect = false;
while (!flag.compare_exchange_strong(expect, true))
{ expect = false;
}
}
void unlock()
{flag.store(false);
}
}; 当前值与期望值(expect)相等时，修改当前值为设定值(desired,第二个参数)，返回true
当前值与期望值(expect)不等时，将期望值(expect)修改为当前值，返回false
自旋锁：线程获取锁的时候，如果锁被其他线程持有，则当前线程将循环等待，直到获取到锁。
自旋锁等待期间，线程的状态不会改变，线程一直是用户态并且是活动的(active)。
自旋锁如果持有锁的时间太长，则会导致其它等待获取锁的线程耗尽CPU。
自旋锁本身无法保证公平性，同时也无法保证可重入性。
基于自旋锁，可以实现具备公平性和可重入性质的锁
读写锁相比互斥锁，读写锁允许更高的并行性，互斥量要么锁住状态要么不加锁，而且一次只有一个线程可以加锁。
读写锁可以有三种状态：
锁定互斥。若另一线程已锁定互斥，则lock的调用线程将阻塞执行，直至获得锁。
若已以任何模式（共享或排他性）占有 mutex 的线程调用 lock ，则行为未定义。也就是说，已经获得读模式锁或者写模式锁的线程再次调用lock的话，行为是未定义的。
注意：通常不直接使用std::shared_mutex::lock()，而是通过unique_lock或者lock_guard进行管理。
解锁互斥。
互斥必须为当前执行线程所锁定，否则行为未定义。如果当前线程不拥有该互斥还去调用unlock，那么就不知道去unlock谁，行为是未定义的。
注意：通常不直接调用 unlock() 而是用 std::unique_lock 与 std::lock_guard 管理排他性锁定。
相比mutex，shared_mutex还拥有lock_shared函数。
该函数获得互斥的共享所有权。若另一线程以排他性所有权保有互斥，则lock_shared的调用者将阻塞执行，直到能取得共享所有权。
若已以任何模式（排他性或共享）占有 mutex 的线程调用 lock_shared ，则行为未定义。即：当以读模式或者写模式拥有锁的线程再次调用lock_shared时，行为是未定义的，可能产生死锁。
若多于实现定义大数量的共享所有者已以共享模式锁定互斥，则 lock_shared 阻塞执行，直至共享所有者的数量减少。所有者的大数量保证至少为 10000。
注意：通常不直接调用 lock_shared() 而是用 std::shared_lock 管理共享锁定。
shared_lock与unique_lock的使用方法类似、
将互斥从调用方线程的共享所有权释放。
当前执行线程必须以共享模式锁定互斥，否则行为未定义。
通常不直接调用 unlock_shared() 而是用 std::shared_lock 管理共享锁定。
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧