悠悠楠杉
网站页面
C++如何使用互斥锁(mutex)保护共享数据
11/14
在现代C++开发中，多线程编程已经成为提升程序性能的重要手段。然而，多个线程同时访问同一块共享数据时，若不加控制，极易引发数据竞争（data race），导致程序行为不可预测，甚至崩溃。为解决这一问题，C++标准库提供了 std::mutex 工具，用于实现线程间的互斥访问，确保共享资源的安全读写。
设想一个简单的场景：两个线程同时对一个全局计数器进行递增操作。如果没有同步机制，两个线程可能在同一时刻读取相同的值，各自加1后再写回，最终结果只增加了1，而不是预期的2。这种问题正是我们需要互斥锁来避免的典型情况。
std::mutex 是C++11引入的标准库组件，定义在 <mutex> 头文件中。它提供了一种“锁”的机制：当一个线程成功获取锁后，其他试图获取该锁的线程将被阻塞，直到持有锁的线程释放它。这样就能保证在任意时刻，最多只有一个线程可以进入临界区——即访问共享资源的代码段。
下面是一个使用 std::mutex 保护共享数据的完整示例：
cpp
include
include
include
include
int sharedcounter = 0; std::mutex countermutex;
void incrementcounter(int iterations) {
for (int i = 0; i < iterations; ++i) {
countermutex.lock();
++sharedcounter;
countermutex.unlock();
}
}
int main() {
const int numthreads = 4;
const int incrementsper_thread = 10000;
std::vector<std::thread> threads;
for (int i = 0; i < num_threads; ++i) {
threads.emplace_back(increment_counter, increments_per_thread);
}
for (auto& t : threads) {
t.join();
}
std::cout << "Final counter value: " << shared_counter << std::endl;
return 0;
}
在这个例子中，我们创建了四个线程，每个线程对 shared_counter 执行一万次递增操作。通过在每次修改前调用 counter_mutex.lock() 和修改后调用 counter_mutex.unlock()，我们确保了任意时刻只有一个线程能修改计数器。最终输出应为 40000，表明所有递增操作都正确执行。
然而，直接手动调用 lock() 和 unlock() 存在一个潜在风险：如果在临界区内发生异常或提前返回，unlock() 可能不会被执行，从而导致死锁。为避免这种情况，C++ 提供了更安全的 RAII（Resource Acquisition Is Initialization）机制——std::lock_guard。
std::lock_guard 是一个轻量级的包装类，它在构造时自动加锁，在析构时自动解锁。即使函数因异常退出，局部对象的析构仍会被调用，从而保证锁的正确释放。使用 std::lock_guard 改写上述函数如下：
cpp
void increment_counter(int iterations) {
for (int i = 0; i < iterations; ++i) {
std::lock_guard<std::mutex> guard(counter_mutex);
++shared_counter;
}
}
这段代码不仅更简洁，也更加安全。guard 对象的作用域仅限于 for 循环的单次迭代，每次进入循环体时加锁，离开时自动解锁，无需担心遗漏解锁操作。
除了 std::mutex 和 std::lock_guard，C++ 还提供了 std::unique_lock 和 std::recursive_mutex 等更高级的同步工具，适用于更复杂的场景，比如条件变量配合使用或递归加锁。但在大多数情况下，std::mutex 配合 std::lock_guard 已经足够应对常见的线程同步需求。
值得注意的是，虽然互斥锁能有效防止数据竞争，但它也会带来性能开销。频繁加锁和解锁可能导致线程阻塞，降低并发效率。因此，在设计多线程程序时，应尽量减少临界区的范围，避免在锁内执行耗时操作，如I/O或网络请求。
