# 实战指南：C++11线程库中的并发编程核心机制
C++11标准引入的线程库，标志着C++语言原生支持多线程编程时代的开启。这一套完整的并发编程组件，包括线程管理、互斥锁、条件变量和原子操作，为开发者提供了跨平台的并发能力。理解这些机制的原理与用法，是编写高效、安全并发程序的基础。
## 线程的创建与生命周期管理
C++11通过`std::thread`类表示执行线程。创建线程时，需要传入可调用对象——可以是函数指针、函数对象或lambda表达式。线程对象创建后即开始执行，主线程需通过`join()`等待子线程结束，或通过`detach()`分离线程使其在后台运行。
```cpp
#include
#include
#include
void worker(int id) {
std::cout << "线程 " << id << " 开始工作" << std::endl;
// 模拟耗时操作
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::cout << "线程 " << id << " 工作完成" << std::endl;
}
int main() {
std::vector
// 创建多个线程
for (int i = 0; i < 5; ++i) {
threads.emplace_back(worker, i);
}
// 等待所有线程完成
for (auto& t : threads) {
t.join();
}
return 0;
}
```
线程的析构函数行为需要特别注意：如果线程对象析构时仍处于可join状态，程序会终止。因此在异常处理场景下，通常使用RAII包装类确保线程正确join。
## 数据竞争与互斥锁
当多个线程同时访问共享数据，且至少有一个线程进行写操作时，就会产生数据竞争。C++11提供`std::mutex`作为基本互斥工具，通过`lock()`和`unlock()`保护临界区。但更推荐使用`std::lock_guard`或`std::unique_lock`，它们遵循RAII原则，在构造时加锁，析构时自动解锁。
```cpp
#include
#include
#include
#include
std::mutex mtx;
int shared_counter = 0;
void increment(int iterations) {
for (int i = 0; i < iterations; ++i) {
std::lock_guard
++shared_counter;
// lock_guard析构时自动释放锁
}
}
int main() {
const int iterations = 10000;
std::thread t1(increment, iterations);
std::thread t2(increment, iterations);
<"f0.p5k3.org.cn"><"z4.p5k3.org.cn"><"j6.p5k3.org.cn">
t1.join();
t2.join();
std::cout << "最终计数: " << shared_counter << std::endl;
return 0;
}
```
对于需要更灵活锁管理的场景，`std::unique_lock`提供延迟加锁、尝试加锁和转移锁所有权的能力。
## 死锁的预防与处理
死锁是多线程编程中的典型问题，通常发生在两个线程互相等待对方持有的资源时。C++11提供`std::lock`函数，可以同时锁定多个互斥锁，避免因加锁顺序不同导致的死锁。
```cpp
std::mutex mtx1, mtx2;
void deadlock_free_operation() {
// 同时锁定两个互斥锁
std::lock(mtx1, mtx2);
// 使用lock_guard管理锁，指定已锁定状态
std::lock_guard
std::lock_guard
// 执行共享数据操作
}
```
采用层级锁策略也是一种常见实践：为互斥锁分配层级，规定加锁顺序必须从低层级到高层级，违反规则的加锁尝试会被拒绝。
## 条件变量的同步机制
条件变量`std::condition_variable`用于实现线程间的等待与通知机制。它允许一个线程等待某个条件成立，而其他线程在条件满足时发出通知。条件变量通常与互斥锁配合使用，并需要配合一个共享条件进行判断。
```cpp
#include
#include
#include
#include
#include
std::queue
std::mutex queue_mtx;
std::condition_variable queue_cv;
void producer() {
for (int i = 0; i < 10; ++i) {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::lock_guard
data_queue.push(i);
std::cout << "生产者生产: " << i << std::endl;
queue_cv.notify_one(); // 通知一个等待线程
}
}
void consumer() {
while (true) {
std::unique_lock
// 等待条件成立，lambda表达式避免虚假唤醒
queue_cv.wait(lock, [] { return !data_queue.empty(); });
int value = data_queue.front();
data_queue.pop();
lock.unlock(); // 尽早释放锁
std::cout << "消费者消费: " << value << std::endl;
if (value == 9) break;
}
}
int main() {
std::thread prod(producer);
std::thread cons(consumer);
prod.join();
cons.join();
return 0;
}
```
`wait()`调用会原子性地释放互斥锁并使线程阻塞，收到通知后重新获取锁并检查条件。这种设计确保条件检查与等待操作之间的原子性。
## 原子操作与内存序
对于简单的整型操作，使用互斥锁可能带来不必要的开销。C++11提供`std::atomic`模板，实现无锁的原子操作，在多核环境下保证操作的事务性。
```cpp
#include
#include
#include
#include
std::atomic
<"n3.p5k3.org.cn"><"w7.p5k3.org.cn"><"g9.p5k3.org.cn">
void atomic_increment(int iterations) {
for (int i = 0; i < iterations; ++i) {
atomic_counter.fetch_add(1, std::memory_order_relaxed);
// 等价于 atomic_counter++
}
}
int main() {
const int iterations = 100000;
std::thread t1(atomic_increment, iterations);
std::thread t2(atomic_increment, iterations);
t1.join();
t2.join();
std::cout << "原子计数: " << atomic_counter << std::endl;
return 0;
}
```
原子操作支持多种内存序（memory order），用于控制操作的内存可见性顺序。默认的`memory_order_seq_cst`提供顺序一致性，但开销较大；在不需要严格顺序的场景下，可使用`memory_order_relaxed`提升性能。
`std::atomic`还支持更复杂的操作如`compare_exchange_weak`和`compare_exchange_strong`，是实现无锁数据结构的基础。
## 线程局部存储
某些场景下，我们希望每个线程拥有独立的变量副本，避免共享带来的同步开销。C++11通过`thread_local`关键字实现线程局部存储，每个线程访问该变量时都会获得独立实例。
```cpp
#include
#include
thread_local int tls_value = 0;
void thread_function(int id) {
tls_value = id;
std::cout << "线程 " << id << " 的tls_value: " << tls_value << std::endl;
// 模拟工作后再次读取，确认值未被其他线程修改
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::cout << "线程 " << id << " 再次读取: " << tls_value << std::endl;
}
int main() {
std::thread t1(thread_function, 1);
std::thread t2(thread_function, 2);
t1.join();
t2.join();
return 0;
}
```
线程局部存储常用于实现线程池中的上下文信息、每个线程的随机数种子等场景。
从线程创建到同步机制，从原子操作到线程局部存储，C++11线程库构建了一套完整的并发编程体系。掌握这些工具的原理与使用场景，能够帮助开发者编写出正确、高效的并发程序。