首先给出基本框架
#include <iostream>
#include <thread>
using namespace std;
int main(){
int n = 100;
int i = 0;
//创建两个线程
thread newThread1([&n, &i](){
while(i < n){
cout << this_thread::get_id() << ": " << i << endl;
i++;
}
});
thread newThread2([&n, &i](){
while(i < n){
cout << this_thread::get_id() << ": " << i << endl;
i++;
}
});
if(newThread1.joinable()){
newThread1.join();
}
if(newThread2.joinable()){
newThread2.join();
}
return 0;
}
这显然没有完成两个线程交替打印的目的，因为共享变量i是临界资源，所以会造成线程争抢，线程不安全，解决方法也很简单，创建一个互斥量mutex并在临界区合适的地方加锁和解锁。由于线程执行函数使用了lambda表达式，为了让两个线程使用同一把锁，把锁创建在了main函数内，并在lambda表达式内使用了引用捕捉。
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int main(){
int n = 100;
int i = 0;
mutex mtx;
//创建两个线程
thread newThread1([&n, &i, &mtx](){
while(i < n){
mtx.lock();
cout << this_thread::get_id() << ": " << i << endl;
i++;
mtx.unlock();
}
});
thread newThread2([&n, &i, &mtx](){
while(i < n){
mtx.lock();
cout << this_thread::get_id() << ": " << i << endl;
i++;
mtx.unlock();
}
});
if(newThread1.joinable()){
newThread1.join();
}
if(newThread2.joinable()){
newThread2.join();
}
return 0;
}
但是在C++中，一般不操作锁，而是由类去管理，管理锁的类一般分为：
template <class Mutex> class lock_guard;template <class Mutex> class unique_lock;
其中第一种只有构造和析构函数，是锁的RAII简单实现。
第二种是通用互斥锁包装器，支持延迟锁定，锁定的有时限尝试，递归锁定，所有权转移和与条件变量一起使用。
unique_lock比lock_guard更加灵活，功能更加强大；带来的缺点就是付出更多的时间和性能成本。
这里使用第二种以便于之后与条件变量一起使用：
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int main(){
int n = 100;
int i = 0;
mutex mtx;
//创建两个线程
thread newThread1([&n, &i, &mtx](){
while(i < n){
unique_lock<mutex> LockManage(mtx);
cout << this_thread::get_id() << ": " << i << endl;
i++;
}
});
thread newThread2([&n, &i, &mtx](){
while(i < n){
unique_lock<mutex> LockManage(mtx);
cout << this_thread::get_id() << ": " << i << endl;
i++;
}
});
if(newThread1.joinable()){
newThread1.join();
}
if(newThread2.joinable()){
newThread2.join();
}
return 0;
}
此时线程安全，但是若其中一个线程竞争锁的能力比较强，就会出现上述情况，大多数打印操作均由一个线程完成。
添加控制：一个线程执行一次后，再去执行就不被允许了，同时唤醒另外一个线程去执行。解决方案是添加一个条件变量，让某个线程在该条件变量下的阻塞队列等待。
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
using namespace std;
int main(){
int n = 100;
int i = 0;
mutex mtx;
condition_variable cv;
bool flag = false;
//创建两个线程
thread newThread1([&n, &i, &mtx, &cv, &flag](){
while(i < n){
unique_lock<mutex> LockManage(mtx);
//!flag为真，获取后不会阻塞，优先运行
cv.wait(LockManage, [&flag]() {return !flag; });
cout << this_thread::get_id() << ": " << i << endl;
i++;
flag = true;
cv.notify_one();
//调用notify_one()随机唤醒一个阻塞的线程，而其余线程仍处于阻塞状态，等待下一次唤醒。
}
});
thread newThread2([&n, &i, &mtx, &cv, &flag](){
while(i < n){
unique_lock<mutex> LockManage(mtx);
//!flag为假，竞争到锁后由于条件不满足，阻塞
cv.wait(LockManage, [&flag]() {return flag; });
cout << this_thread::get_id() << ": " << i << endl;
i++;
flag = false;
cv.notify_one();
}
});
if(newThread1.joinable()){
newThread1.join();
}
if(newThread2.joinable()){
newThread2.join();
}
return 0;
}
最终实现了两进程交替打印奇偶数。
