线程创建和接收

 std::this_thread::get_id()获取当前线程的线程ID

std::this_thread::yield()让步结束当前线程的时间片

int main()
{vector<thread> threads(2);threads[0] = thread([]() {cout << this_thread::get_id() << endl;});threads[1] = thread([]() {cout << this_thread::get_id() << endl;});thread thread3([]() {cout << this_thread::get_id() << endl;});for (auto& e : threads){e.join();}thread3.join();return 0;
}
//14136
//15844
//16272

原子操作

多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的，那么没问 题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数 据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦。比如：

int main()
{int val = 0;vector<thread> threads(2);threads[0] = thread([&](int n) {for (int i = 0; i < n; ++i){++val;}}, 100000);threads[1] = thread([&](int n) {for (int i = 0; i < n; ++i){++val;}}, 200000);for (auto& e : threads){e.join();}cout << val << endl;return 0;
}

这个程序跑出来的结果不确定，有时候会比较小，这都是由于多线程导致的数据不一致。

虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻 塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。

因此C++11中引入了原子操作。所谓原子操作：即不可被中断的一个或一系列操作，C++11引入 的原子操作类型，使得线程间数据的同步变得非常高效。

原子类模板完全专门用于所有基本整数类型（bool 除外），以及 <cstdint> 中的 typedef 所需的任何扩展整数类型。 这些特化具有以下附加成员函数：

 在C++11中，程序员不需要对原子类型变量进行加锁解锁操作，线程能够对原子类型变量互斥的 访问。 更为普遍的，程序员可以使用atomic类模板，定义出需要的任意原子类型。

同时atomic_int与aotmic<int>完全一样。

int main()
{atomic_int val = 0;vector<thread> threads(2);threads[0] = thread([&](int n) {for (int i = 0; i < n; ++i){++val;}}, 100000);threads[1] = thread([&](int n) {for (int i = 0; i < n; ++i){++val;}}, 200000);for (auto& e : threads){e.join();}cout << val << endl;return 0;
}

这个程序就完全保证了++的原子性。

在C++11 中，原子类型只能从其模板参数中进行构造，不允许原子类型进行拷贝构造、移动构造以及 operator=等，为了防止意外，标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算 符重载默认删除掉了。

原子操作的本质是CAS（compare and  swap）: 寄存器中的值写回内存时，将当初提取的旧值与现在内存中的值比较，如果一样就写回去，如果不一样再次从内存中提取，重复操作。

mutex的种类

在C++11中，Mutex总共包了四个互斥量的种类：

std::mutex

C++11提供的最基本的互斥量，该类的对象之间不能拷贝，也不能进行移动。

std::recursive_mutex

递归互斥锁：其允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权， 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，除此之外， std::recursive_mutex 的特性和 std::mutex 大致相同。

判断获取锁的线程与当前要加锁的线程是不是同一个，如果是就不阻塞。

std::timed_mutex

比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until() 。

try_lock_for()

接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与 std::mutex 的 try_lock() 不同，try_lock 如果被调用时没有获得锁则直接返回 false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超 时（即在指定时间内还是没有获得锁），则返回 false。

try_lock_until()

接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住， 如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指 定时间内还是没有获得锁），则返回 false。

std::recursive_timed_mutex不作讲解

guard_lock的改进版本unique_lock

与lock_gard类似，unique_lock类模板也是采用RAII的方式对锁进行了封装，并且也是以独占所 有权的方式管理mutex对象的上锁和解锁操作，即其对象之间不能发生拷贝。在构造(或移动 (move)赋值)时，unique_lock 对象需要传递一个 Mutex 对象作为它的参数，新创建的 unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。使用以上类型互斥量实例化 unique_lock的对象时，自动调用构造函数上锁，unique_lock对象销毁时自动调用析构函数解 锁，可以很方便的防止死锁问题。

条件变量condition_variable

条件变量本身不是线程安全的，需要和锁（只能是unique_lock，可以在条件等待时解锁）配合。

支持两个线程交替打印，一个打印奇数，一个打印偶

反复询问，消耗CPU资源

int main()
{int val = 0;int n = 100;vector<thread> threads(2);threads[0] = thread([&]() {while (val <= 100){if (0 == val % 2){cout << this_thread::get_id() << "->" << val << endl;++val;}}});threads[1] = thread([&]() {while (val < 100){if (val % 2){cout << this_thread::get_id() << "->" << val << endl;++val;}}});for (auto& e : threads){e.join();}//cout << val << endl;return 0;
}

条件变量等待唤醒

int main()
{int val = 0;int n = 10000;condition_variable cond;mutex mt;vector<thread> threads(2);threads[0] = thread([&]() {while (val <= n){{unique_lock<mutex> ulk(mt);cond.wait(ulk, [&]() {return 0 == val % 2;});cout << this_thread::get_id() << "->" << val << endl;++val;cond.notify_one();}}});threads[1] = thread([&]() {while (val < n){{unique_lock<mutex> ulk(mt);cond.wait(ulk, [&]() {return val % 2;});cout << this_thread::get_id() << "->" << val << endl;++val;cond.notify_one();}}});for (auto& e : threads){e.join();}//cout << val << endl;return 0;
}

注意，下面两种使用完全一样：

while (i % 2) cv.wait(lock); cv.wait(lock, [&i] {return i % 2 == 0; });