好的，各位观众，欢迎来到今天的“C++并发容器性能大乱斗”现场！今天我们要聊的是C++并发容器背后的两位重量级选手：std::mutex（互斥锁）和std::shared_mutex（共享互斥锁）。别看它们名字挺严肃，其实它们的作用很简单，就是为了保证多个线程访问共享数据时，不会出现“你抢我的笔，我撕你的纸”的混乱局面。
一、并发容器的“烦恼”：线程安全问题
在单线程的世界里，大家相安无事，数据想怎么改就怎么改。但是一旦引入了多线程，问题就来了。想象一下，多个线程同时修改一个变量，如果没有保护措施，结果很可能是：
- 数据竞争（Data Race）： 多个线程同时访问并修改同一块内存区域，导致结果不可预测。
- 脏数据（Dirty Data）： 一个线程读取到的数据是另一个线程未完成修改的数据，导致数据不一致。
为了解决这些问题，我们需要并发容器。并发容器，顾名思义，就是为了在并发环境下安全地存储和访问数据的容器。它们通常会使用锁机制来保护内部数据，确保线程安全。
二、std::mutex：简单粗暴的“单行道”
std::mutex是最基础的互斥锁，它的工作方式非常简单：
- 加锁（lock）： 某个线程想要访问共享数据，必须先获得锁。如果锁已经被其他线程占用，则该线程会被阻塞，直到锁被释放。
- 解锁（unlock）： 线程访问完共享数据后，必须释放锁，以便其他线程可以访问。
简单来说，std::mutex就像一条单行道，每次只允许一辆车（一个线程）通过。
代码示例：使用std::mutex保护共享变量
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 定义一个互斥锁
int shared_variable = 0;
void increment_variable() {
for (int i = 0; i < 100000; ++i) {
mtx.lock(); // 加锁
shared_variable++;
mtx.unlock(); // 解锁
}
}
int main() {
std::thread t1(increment_variable);
std::thread t2(increment_variable);
t1.join();
t2.join();
std::cout << "Shared variable value: " << shared_variable << std::endl; // 预期结果：200000
return 0;
}在这个例子中，mtx.lock()和mtx.unlock()之间的代码块是受保护的临界区（critical section）。只有持有锁的线程才能执行临界区内的代码。
优点：
- 简单易用：
std::mutex的接口非常简单，容易理解和使用。 - 适用性广： 适用于需要独占访问共享资源的场景。
缺点：
- 并发度低： 任何时候只能有一个线程访问共享资源，即使有些线程只是想读取数据，也必须等待锁释放，导致并发度较低。
- 可能导致死锁： 如果多个线程以不同的顺序请求锁，可能会导致死锁。
三、std::shared_mutex：允许多人阅读的“图书馆”
std::shared_mutex是共享互斥锁，它允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。它的工作方式如下：
- 共享模式（shared mode）： 多个线程可以同时以共享模式持有锁，用于读取共享资源。
- 独占模式（exclusive mode）： 只有一个线程可以以独占模式持有锁，用于写入共享资源。
std::shared_mutex就像一个图书馆，允许很多人同时阅读书籍（共享模式），但只允许一个人修改书籍（独占模式）。
代码示例：使用std::shared_mutex实现读写锁
#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>
std::shared_mutex shared_mtx; // 定义一个共享互斥锁
std::vector<int> data;
void read_data() {
for (int i = 0; i < 5; ++i) {
shared_mtx.lock_shared(); // 以共享模式加锁
std::cout << "Thread " << std::this_thread::get_id() << " reading data: ";
for (int value : data) {
std::cout << value << " ";
}
std::cout << std::endl;
shared_mtx.unlock_shared(); // 释放共享锁
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
void write_data() {
for (int i = 0; i < 3; ++i) {
shared_mtx.lock(); // 以独占模式加锁
data.push_back(i);
std::cout << "Thread " << std::this_thread::get_id() << " writing data: " << i << std::endl;
shared_mtx.unlock(); // 释放独占锁
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
}
int main() {
std::thread reader1(read_data);
std::thread reader2(read_data);
std::thread writer(write_data);
reader1.join();
reader2.join();
writer.join();
return 0;
}在这个例子中，read_data()函数使用lock_shared()和unlock_shared()来以共享模式持有和释放锁，而write_data()函数使用lock()和unlock()来以独占模式持有和释放锁。
优点：
- 并发度高： 允许多个线程同时读取共享资源，提高了并发度。
- 适用于读多写少场景： 在读多写少的场景下，可以显著提高性能。
缺点：
- 实现复杂：
std::shared_mutex的实现比std::mutex复杂，需要更多的开销。 - 可能导致写饥饿： 如果一直有线程以共享模式持有锁，写线程可能一直无法获得锁，导致写饥饿。
四、std::mutex vs std::shared_mutex：性能大比拼
那么，std::mutex和std::shared_mutex在性能方面有什么区别呢？让我们来做个简单的对比：
| 特性 | std::mutex |
std::shared_mutex |
|---|---|---|
| 并发度 | 低 | 高 (读多写少场景) |
| 实现复杂度 | 简单 | 复杂 |
| 适用场景 | 独占访问 | 读多写少 |
| 开销 | 低 | 高 |
| 写饥饿风险 | 无 | 有 |
性能测试：
为了更直观地了解它们的性能差异，我们可以进行一些简单的性能测试。以下是一个简单的测试代码，用于比较std::mutex和std::shared_mutex在读多写少场景下的性能：
#include <iostream>
#include <thread>
#include <mutex>
#include <shared_mutex>
#include <vector>
#include <chrono>
const int NUM_READERS = 10;
const int NUM_WRITERS = 1;
const int NUM_ITERATIONS = 100000;
// 使用 std::mutex 的测试函数
void test_mutex(std::mutex& mtx, std::vector<int>& data) {
auto start = std::chrono::high_resolution_clock::now();
std::vector<std::thread> threads;
for (int i = 0; i < NUM_READERS; ++i) {
threads.emplace_back([&mtx, &data]() {
for (int j = 0; j < NUM_ITERATIONS; ++j) {
mtx.lock();
// 模拟读取操作
int sum = 0;
for (int value : data) {
sum += value;
}
mtx.unlock();
}
});
}
for (int i = 0; i < NUM_WRITERS; ++i) {
threads.emplace_back([&mtx, &data]() {
for (int j = 0; j < NUM_ITERATIONS / 10; ++j) {
mtx.lock();
// 模拟写入操作
data.push_back(j);
data.erase(data.begin());
mtx.unlock();
}
});
}
for (auto& thread : threads) {
thread.join();
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout << "std::mutex: " << duration.count() << " ms" << std::endl;
}
// 使用 std::shared_mutex 的测试函数
void test_shared_mutex(std::shared_mutex& shared_mtx, std::vector<int>& data) {
auto start = std::chrono::high_resolution_clock::now();
std::vector<std::thread> threads;
for (int i = 0; i < NUM_READERS; ++i) {
threads.emplace_back([&shared_mtx, &data]() {
for (int j = 0; j < NUM_ITERATIONS; ++j) {
shared_mtx.lock_shared();
// 模拟读取操作
int sum = 0;
for (int value : data) {
sum += value;
}
shared_mtx.unlock_shared();
}
});
}
for (int i = 0; i < NUM_WRITERS; ++i) {
threads.emplace_back([&shared_mtx, &data]() {
for (int j = 0; j < NUM_ITERATIONS / 10; ++j) {
shared_mtx.lock();
// 模拟写入操作
data.push_back(j);
data.erase(data.begin());
shared_mtx.unlock();
}
});
}
for (auto& thread : threads) {
thread.join();
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout << "std::shared_mutex: " << duration.count() << " ms" << std::endl;
}
int main() {
std::vector<int> data1(100);
std::vector<int> data2(100);
std::mutex mtx;
std::shared_mutex shared_mtx;
std::cout << "Running tests with " << NUM_READERS << " readers and " << NUM_WRITERS << " writer..." << std::endl;
test_mutex(mtx, data1);
test_shared_mutex(shared_mtx, data2);
return 0;
}测试结果分析：
在读多写少的场景下，std::shared_mutex通常会比std::mutex表现更好，因为它可以允许多个读线程同时访问共享数据。但在写多读少的场景下，std::mutex可能会表现更好，因为std::shared_mutex的写操作需要等待所有读线程释放锁。
五、选择合适的锁：具体问题具体分析
那么，在实际开发中，我们应该如何选择std::mutex和std::shared_mutex呢？
- 如果共享资源需要独占访问，或者写入操作非常频繁，那么
std::mutex是更好的选择。 - 如果共享资源主要是被读取，而写入操作比较少，那么
std::shared_mutex可以提高并发度，从而提高性能。
除了考虑读写比例之外，还需要考虑以下因素：
- 锁的开销：
std::shared_mutex的开销比std::mutex高，如果共享资源的访问非常快，那么使用std::shared_mutex可能会适得其反。 - 写饥饿风险： 如果使用
std::shared_mutex，需要注意写饥饿风险，可以考虑使用一些策略来避免写饥饿，例如优先级反转。 - 代码复杂度：
std::shared_mutex的使用比std::mutex复杂，需要更多的代码来管理锁的生命周期。
六、更高级的并发控制技术
除了std::mutex和std::shared_mutex之外，C++还提供了其他一些并发控制技术，例如：
- 原子操作（Atomic Operations）： 原子操作是一种不可分割的操作，可以保证在多线程环境下对共享变量的访问是安全的。
- 条件变量（Condition Variables）： 条件变量用于线程间的同步，允许线程等待某个条件的发生。
- 信号量（Semaphores）： 信号量用于控制对共享资源的访问数量。
这些技术可以提供更细粒度的并发控制，从而实现更高的性能。
七、总结：选择合适的工具，才能事半功倍
std::mutex和std::shared_mutex是C++并发编程中常用的两种锁机制。std::mutex简单易用，适用于需要独占访问共享资源的场景。std::shared_mutex可以提高读多写少场景下的并发度，但实现复杂，需要注意写饥饿风险。
在实际开发中，我们需要根据具体情况选择合适的锁机制，才能充分发挥并发编程的优势，提高程序的性能和可靠性。记住，没有银弹，只有最适合的工具！
好了，今天的“C++并发容器性能大乱斗”就到这里，希望大家有所收获！感谢大家的观看，我们下次再见！