Linux下C++多线程同步：从互斥锁到屏障的实战指南
在Linux平台上用C++搞多线程开发，线程同步是个绕不开的核心议题。处理不好，数据竞争、死锁这些“坑”随时可能出现。那么，有哪些趁手的同步工具可供选择呢？它们的典型用法又是怎样的？
下面，我们就来梳理几种C++标准库中常用的线程同步机制，并配上直观的代码示例。
1. 互斥锁（Mutex）
这大概是大家最熟悉的同步原语了。它的职责非常明确：保护共享资源，确保同一时刻只有一个线程能访问它，相当于给临界区上了一把独占的锁。
#include
#include
#include
std::mutex mtx; // 定义一个互斥锁
void print_block(int n, char c) {
mtx.lock(); // 加锁
for (int i = 0; i < n; ++i) {
std::cout << c;
}
std::cout << '\n';
mtx.unlock(); // 解锁
}
int main() {
std::thread th1(print_block, 50, '*');
std::thread th2(print_block, 50, '$');
th1.join();
th2.join();
return 0;
} 看这段代码，两个线程都想往控制台打印字符。如果没有互斥锁，输出可能会混杂在一起。而mtx.lock()和mtx.unlock()这对操作，就保证了每个线程的打印区块是完整的。
2. 递归互斥锁（Recursive Mutex）
普通互斥锁有个限制：同一个线程不能重复上锁，否则会立刻导致死锁。但有些场景下，我们可能需要函数递归调用，或者一个公共函数本身就需要加锁。这时候，递归互斥锁就派上用场了。
#include
#include
#include
std::recursive_mutex mtx; // 定义一个递归互斥锁
void print_block(int n, char c) {
mtx.lock(); // 加锁
if (n > 0) {
std::cout << c;
mtx.lock(); // 再次加锁
print_block(n - 1, c);
mtx.unlock(); // 解锁
}
std::cout << '\n';
mtx.unlock(); // 解锁
}
int main() {
std::thread th1(print_block, 50, '*');
std::thread th2(print_block, 50, '$');
th1.join();
th2.join();
return 0;
} 注意看，在递归函数print_block内部，同一个线程对mtx执行了多次lock()。如果换成普通的std::mutex，程序就会卡住。而std::recursive_mutex允许这种行为，只要确保加锁和解锁的次数匹配即可。
3. 条件变量（Condition Variable）
互斥锁解决了互斥访问的问题，但线程间有时需要“等待某个条件成立”。比如，一个线程要等队列非空才能取数据，另一个线程放入数据后需要通知它。这就是条件变量的典型应用场景。
#include
#include
#include
#include
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void print_id(int id) {
std::unique_lock lck(mtx);
cv.wait(lck, []{return ready;}); // 等待条件变量
std::cout << "Thread " << id << '\n';
}
void go() {
std::lock_guard lck(mtx);
ready = true;
cv.notify_all(); // 通知所有等待的线程
}
int main() {
std::thread threads[10];
for (int i = 0; i < 10; ++i) {
threads[i] = std::thread(print_id, i);
}
std::this_thread::sleep_for(std::chrono::seconds(1)); // 等待一段时间
go(); // 通知线程开始执行
for (auto& th : threads) {
th.join();
}
return 0;
} 这个例子展示了经典的“等待-通知”模式。10个线程启动后都在条件变量cv上等待，直到主线程调用go()将ready置为true并发出notify_all()信号，所有等待的线程才继续执行。cv.wait()的第二个参数是一个谓词（lambda表达式），它避免了虚假唤醒，是更健壮的写法。
4. 读写锁（Reader-Writer Lock）
对于“读多写少”的共享数据，使用互斥锁会限制并发性能，因为读操作之间本可以不互斥。读写锁（C++17起为std::shared_mutex）应运而生，它允许多个读线程同时持有锁，但写线程独占锁。
#include
#include
#include
std::shared_mutex rw_mtx; // 定义一个读写锁
int shared_data = 0;
void read_data() {
std::shared_lock lck(rw_mtx); // 读锁
std::cout << "Read data: " << shared_data << '\n';
}
void write_data(int value) {
std::unique_lock lck(rw_mtx); // 写锁
shared_data = value;
std::cout << "Write data: " << shared_data << '\n';
}
int main() {
std::thread readers[5];
std::thread writer(write_data, 42);
for (auto& th : readers) {
th = std::thread(read_data);
}
for (auto& th : readers) {
th.join();
}
writer.join();
return 0;
} 使用时要注意区分：读操作使用std::shared_lock，写操作使用std::unique_lock。这样，多个read_data线程可以并发执行，而write_data线程执行时，所有读写线程都必须等待。
5. 屏障（Barrier）
最后来看看屏障。它的概念很简单：设置一个同步点，要求指定数量的线程都到达这个点后，大家才能一起继续往下执行。这在分阶段并行计算的场景中非常有用。
#include
#include
#include
#include
std::barrier sync_point(3); // 定义一个屏障，等待3个线程
void do_work(int id) {
std::cout << "Thread " << id << " is working\n";
sync_point.arrive_and_wait(); // 等待其他线程
std::cout << "Thread " << id << " has passed the barrier\n";
}
int main() {
std::vector threads;
for (int i = 0; i < 3; ++i) {
threads.emplace_back(do_work, i);
}
for (auto& th : threads) {
th.join();
}
return 0;
} 代码中，屏障sync_point被设置为需要等待3个线程。每个线程完成自己的“工作”阶段后，调用arrive_and_wait()，直到另外两个线程也到达此处，三个线程才会同时继续执行“通过屏障后”的代码。
以上就是C++中几种主流的线程同步机制。简单总结一下：互斥锁是基础，递归互斥锁解决特定嵌套问题，条件变量用于线程间协作，读写锁优化读多写少场景，屏障则用于阶段性的线程汇合。在实际开发中，根据具体的需求场景选择合适的同步工具，是构建健壮、高效多线程程序的关键一步。
