例一：给上面的代码加锁

#include <iostream>
#include <thread>
#include <mutex>using namespace std;mutex mtx; // 创建一把锁void print(int n) {mtx.lock();	// 加锁for (int i = 0; i < n; ++i) {cout << this_thread::get_id() << ":" << i << endl; // 打印 [线程id]:ithis_thread::sleep_for(chrono::milliseconds(100)); // sleep 100 ms}mtx.unlock(); // 解锁
}int main() {thread t1(print, 100);thread t2(print, 100);t1.join();t2.join();return 0;
}

例二：

如果锁是创建在局部，则要通过函数参数传入

由于锁不支持拷贝，所以必须通过引用传入，又由于可变模板参数会默认识别成传值，所以必须先使用 ref 来强制转换成引用。

#include <iostream>
#include <thread>
#include <mutex>using namespace std;void print(int n, mutex& mtx) {mtx.lock();	// 加锁for (int i = 0; i < n; ++i) {cout << this_thread::get_id() << ":" << i << endl; // 打印 [线程id]:ithis_thread::sleep_for(chrono::milliseconds(100)); // sleep 100 ms}mtx.unlock(); // 解锁
}int main() {mutex mtx; // 创建一把锁thread t1(print, 100, ref(mtx)); // 必须使用 ref 来传引用thread t2(print, 100, ref(mtx));t1.join();t2.join();return 0;
}

例三：

配合 vector 和 lambda 使用

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>using namespace std;int main() {mutex mtx; // 创建一把锁int x = 0, n = 10, m;cin >> m;vector<thread> v(m);for (int i = 0; i < m; ++i) {v[i] = thread([&]() {mtx.lock();	// 加锁for (int i = 0; i < n; ++i) {cout << this_thread::get_id() << ":" << i << endl; // 打印 [线程id]:ithis_thread::sleep_for(chrono::milliseconds(100)); // sleep 100 ms}mtx.unlock(); // 解锁});}for (auto& t : v) {t.join();}return 0;
}

如果在递归函数中使用普通的互斥锁会造成死锁，因为当一个线程执行到 unlock 之前就可能会递归调用自己，然后从头开始执行，当再次遇到 lock 时，由于之前没有执行 unlock，就会死锁。

而 recursive_mutex 可以防止递归造成的死锁，它在每次 lock 的时候会判断是不是当前线程，如果是，就不用阻塞，可以继续向下执行了。

定时互斥锁，该类锁可以设置锁住的时间。

由它的两个成员实现 try_lock_for 和 try_lock_until.

到时间后我们不需要手动解锁，而是自动解锁。

智能锁，通过 RAII 技术实现。

它的实现类似于如下方法：

template<class Lock>
class LockGuard {
public:LockGuard(Lock& lk) : _lock(lk) {_lock.lock();}~LockGuard() {_lock.unlock();}
private:Lock& _lock;
};

例：

int main() {mutex mtx; // 创建一把锁atomic<int> x = 0;//int x = 0;int n = 100, m;cin >> m;vector<thread> v(m);for (int i = 0; i < m; ++i) {v[i] = thread([&]() {for (int i = 0; i < n; ++i) {lock_guard<mutex> lk(mtx); // 智能锁cout << this_thread::get_id() << ':' << i << endl;this_thread::sleep_for(chrono::microseconds(100));}});}for (auto& t : v) {t.join();}cout << x << endl;return 0;
}

注：unique_guard 比 lock_guard 多一个支持手动加锁的解锁的功能。

我们知道，++ 操作不是线程安全的，要避免多线程同时修改造成的数据不一致的问题，可以通过加锁来解决。

但是互斥锁会产生上下文切换的开销，容易产生死锁。更好的解决方法是使用原子操作。

CAS （Compare & Set，或 Compare & Swap）是一种原子操作，也就是说它是一个不会被其他线程打断的操作。CAS 有三个操作数：内存值 V，旧的预期值 A，要修改的新值 B。CAS 的过程是这样的：先比较内存值 V 和旧的预期值 A 是否相等，如果相等，就用新值 B 替换内存值 V；如果不相等，就放弃操作或者重试。CAS 可以用于实现无锁算法，避免多线程同时修改同一数据时产生的数据不一致问题。

C++11 中的 atomic 类就是 CAS 的一种实现。

例：

#include <iostream>
#include <thread>
#include <vector>using namespace std;int main() {//int x = 0;atomic<int> x = 0;int n = 100000, m;cin >> m;vector<thread> v(m);for (int i = 0; i < m; ++i) {v[i] = thread([&]() {for (int i = 0; i < n; ++i) {++x;				// 原子操作}});}for (auto& t : v) {t.join();}cout << x << endl;return 0;
}

条件变量是一种同步原语，用于让线程在某个条件发生时才继续执行。 条件变量与互斥锁配合使用，让线程在等待条件时释放锁，从而避免竞争状态。条件变量提供了一种原子操作，即解锁并睡眠的操作，以及唤醒并加锁的操作。条件变量有两个动作：等待（wait）和通知（notify）。等待动作会让线程挂起，并释放已经持有的锁。通知动作会唤醒一个或多个等待的线程，并让它们重新获取锁。

在 C++11 中，你可以使用 std::condition_variable 类来创建和操作条件变量。你需要配合一个互斥锁（std::mutex）和一个谓词（std::function<bool()>）来使用条件变量。你可以调用条件变量的成员函数，如wait()，notify_one()，notify_all()等来实现线程间的同步。

predicate(2) 是增加了谓词的版本，pred 是一个 std::function<bool()>，它返回 false 则表示阻塞，返回 true 时解除阻塞。

例：创建两个线程，交替打印 0~100，如线程 t2 先打印 0，则下面必须是另一个线程 t1 打印 1，然后 t2 打印 2 …

这是一个运用条件变量解决的经典场景，我们可以让一个线程打印完一个数之后立马通知另一个线程，从而保证两个线程交替进行。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>using namespace std;int main() {int i = 0;int n = 100;mutex mtx;condition_variable cv;bool ready = true; // 开始标志，初始为 true，可以使线程 t2 先打印thread t1([&]() {while (i < n) {unique_lock<mutex> lock(mtx); // 条件变量需要的互斥锁cv.wait(lock, [&ready]() {return !ready; }); // 如果 ready 为 true 则阻塞cout << this_thread::get_id() << ":" << i << endl;++i;ready = true;	// 更改条件cv.notify_one();// 唤醒另一个线程}});thread t2([&]() {while (i < n) {unique_lock<mutex> lock(mtx);cv.wait(lock, [&ready]() {return ready; }); // 如果 ready 为 false 则阻塞cout << this_thread::get_id() << ":" << i << endl;++i;ready = false;	// 更改条件cv.notify_one();// 唤醒另一个线程}});t1.join();t2.join();return 0;
}

例2：生产者消费者模型

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>std::mutex mtx; // 互斥锁
std::condition_variable cv; // 条件变量
std::queue<int> q; // 共享队列
bool finished = false; // 结束标志void producer(int n) {for (int i = 0; i < n; ++i) {std::unique_lock<std::mutex> lock(mtx); // 加锁std::this_thread::sleep_for(std::chrono::milliseconds(100));q.push(i); // 生产数据std::cout << "produced " << i << "\n";lock.unlock(); // 解锁cv.notify_one(); // 通知消费者}{std::unique_lock<std::mutex> lock(mtx); // 加锁finished = true; // 设置结束标志}cv.notify_all(); // 通知所有消费者
}void consumer() {while (true) {std::unique_lock<std::mutex> lock(mtx); // 加锁cv.wait(lock, [] {return finished || !q.empty(); }); // 等待条件成立：结束或队列非空if (finished && q.empty()) {break; // 结束且队列空，退出循环}std::this_thread::sleep_for(std::chrono::milliseconds(100));int x = q.front(); // 取出数据q.pop();std::cout << std::this_thread::get_id() << ": consumed " << x << "\n";}
}int main() {std::thread t1(producer, 10); // 创建生产者线程，生产10个数据std::thread t2(consumer); // 创建消费者线程1std::thread t3(consumer); // 创建消费者线程2t1.join();t2.join();t3.join();return 0;
}

运行结果：