讲座主题：如何在C++中实现一个多线程安全的计数器？
大家好！欢迎来到今天的C++技术讲座。今天我们要聊一个非常实用的话题——如何在C++中实现一个多线程安全的计数器。听起来是不是有点复杂？别担心，我会用轻松诙谐的语言，带你一步步搞定这个问题。
为什么需要多线程安全的计数器？
假设你正在开发一个服务器程序，它需要处理多个并发请求。每个请求都会增加或减少某个共享资源的计数。如果这个计数器不是线程安全的，那么可能会出现竞态条件（Race Condition），导致数据不一致。比如，本来应该加10次，结果只加了7次，这可不行！
所以，我们需要一种机制来确保多个线程同时操作计数器时，数据不会出错。这就是我们今天要解决的问题。
C++中的线程同步工具
在C++11之后，标准库提供了丰富的线程支持。我们可以使用以下几种工具来保证线程安全：
std::mutex：互斥锁，用于保护共享资源。std::atomic：原子操作类，提供无锁的线程安全操作。std::lock_guard：RAII风格的锁管理器，简化锁的使用。
接下来，我们将分别用std::mutex和std::atomic实现一个多线程安全的计数器。
方法一：使用std::mutex
实现思路
通过std::mutex，我们可以确保同一时间只有一个线程可以修改计数器。具体步骤如下：
- 定义一个
std::mutex对象。 - 在每次访问计数器时，使用
std::lock_guard自动加锁和解锁。
示例代码
#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
class ThreadSafeCounter {
private:
int count = 0;
std::mutex mtx; // 互斥锁
public:
void increment() {
std::lock_guard<std::mutex> lock(mtx); // 自动加锁和解锁
++count;
}
int getCount() const {
std::lock_guard<std::mutex> lock(mtx);
return count;
}
};
void worker(ThreadSafeCounter& counter) {
for (int i = 0; i < 1000; ++i) {
counter.increment();
}
}
int main() {
ThreadSafeCounter counter;
std::vector<std::thread> threads;
// 创建10个线程，每个线程增加1000次
for (int i = 0; i < 10; ++i) {
threads.emplace_back(worker, std::ref(counter));
}
// 等待所有线程完成
for (auto& t : threads) {
t.join();
}
std::cout << "Final count: " << counter.getCount() << std::endl; // 应该是10000
return 0;
}结果分析
运行上述代码后，最终的计数值应该是10000，因为有10个线程，每个线程增加了1000次。通过std::mutex，我们成功避免了竞态条件。
方法二：使用std::atomic
实现思路
std::atomic是一种轻量级的线程同步工具，适用于简单的计数器场景。它不需要显式加锁，性能通常比std::mutex更高。
示例代码
#include <iostream>
#include <thread>
#include <vector>
#include <atomic>
class AtomicCounter {
private:
std::atomic<int> count{0}; // 原子变量
public:
void increment() {
count.fetch_add(1, std::memory_order_relaxed); // 原子递增
}
int getCount() const {
return count.load(std::memory_order_relaxed); // 原子读取
}
};
void worker(AtomicCounter& counter) {
for (int i = 0; i < 1000; ++i) {
counter.increment();
}
}
int main() {
AtomicCounter counter;
std::vector<std::thread> threads;
// 创建10个线程，每个线程增加1000次
for (int i = 0; i < 10; ++i) {
threads.emplace_back(worker, std::ref(counter));
}
// 等待所有线程完成
for (auto& t : threads) {
t.join();
}
std::cout << "Final count: " << counter.getCount() << std::endl; // 应该是10000
return 0;
}结果分析
与std::mutex版本类似，最终的计数值仍然是10000。但这次我们没有使用显式的锁，而是依赖std::atomic提供的原子操作。
std::mutex vs std::atomic
为了帮助大家更好地理解这两种方法的区别，我制作了一个对比表：
| 特性 | std::mutex |
std::atomic |
|---|---|---|
| 是否需要显式加锁 | 是 | 否 |
| 性能 | 较低（涉及锁开销） | 较高（无锁） |
| 使用场景 | 复杂的多线程同步需求 | 简单的计数器或标志位操作 |
| 内存排序控制 | 需要手动指定内存顺序 | 提供多种内存顺序选项 |
总结
今天我们一起学习了如何在C++中实现一个多线程安全的计数器。我们分别使用了std::mutex和std::atomic两种方法，并通过示例代码展示了它们的用法。
- 如果你的场景比较复杂，涉及多个共享资源的操作，建议使用
std::mutex。 - 如果只是简单的计数器或标志位操作，推荐使用
std::atomic，因为它性能更高。
最后，引用《C++ Concurrency in Action》这本书的一句话：“Concurrency is hard, but it’s not impossible.”（并发很难，但并非不可能。）
希望今天的讲座对你有所帮助！如果有任何问题，欢迎随时提问。下次见啦！
