各位观众，各位朋友，欢迎来到今天的锁粒度优化讲座！我是你们的老朋友，一位在代码世界里摸爬滚打多年的老兵。今天咱们不谈高深的理论，就聊聊C++里锁的那点事儿，特别是粗粒度锁和细粒度锁的选择，这可是并发编程里绕不开的坎儿啊。
第一幕：锁，并发世界的保安
首先，咱们得明白锁是干嘛的。想象一下，你家小区只有一个大门，所有人都想进出。如果没有保安，那肯定乱成一锅粥，谁也别想好好走路。锁，在并发编程里，就扮演着保安的角色，保证多个线程访问共享资源的时候，不会互相干扰，引发数据混乱。
#include <iostream>
#include <thread>
#include <mutex>
int counter = 0;
std::mutex counter_mutex;
void increment_counter() {
for (int i = 0; i < 100000; ++i) {
std::lock_guard<std::mutex> lock(counter_mutex); // 上锁
counter++;
}
}
int main() {
std::thread t1(increment_counter);
std::thread t2(increment_counter);
t1.join();
t2.join();
std::cout << "Counter value: " << counter << std::endl; // 预期结果：200000
return 0;
}上面这段代码，counter 就是我们的共享资源，counter_mutex 就是保护它的锁。std::lock_guard是个好东西，它会在进入代码块的时候自动上锁，离开的时候自动解锁，防止你忘了解锁，导致死锁。
第二幕：粗粒度锁，一刀切的管理
粗粒度锁，就好比小区只有一个保安，管着整个小区的所有出入口。虽然简单粗暴，但是效率嘛，就比较感人了。
想象一下，如果整个小区只有你一个人想出门，但是因为保安要先检查完所有人的身份才能放你走，那你得多憋屈啊！
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
class DataStructure {
public:
void add_data(int data) {
std::lock_guard<std::mutex> lock(mutex_); // 粗粒度锁：整个数据结构操作都加锁
data_.push_back(data);
}
int get_data(int index) {
std::lock_guard<std::mutex> lock(mutex_);
if (index >= 0 && index < data_.size()) {
return data_[index];
} else {
return -1; // 错误处理
}
}
private:
std::vector<int> data_;
std::mutex mutex_;
};
int main() {
DataStructure data_structure;
std::thread t1([&]() {
for (int i = 0; i < 1000; ++i) {
data_structure.add_data(i);
}
});
std::thread t2([&]() {
for (int i = 0; i < 1000; ++i) {
data_structure.get_data(i % 50); // 随机读取
}
});
t1.join();
t2.join();
return 0;
}在这个例子里，DataStructure 的所有操作（add_data 和 get_data）都用同一个 mutex_ 保护。这意味着，只要有一个线程在操作这个数据结构，其他线程就必须等待。这就像所有居民都必须排队才能使用小区的设施，效率可想而知。
粗粒度锁的优点：
- 简单易懂： 容易实现，不容易出错。
- 安全性高： 确保对共享资源的互斥访问，避免数据竞争。
粗粒度锁的缺点：
- 并发度低： 多个线程无法同时访问共享资源，导致性能瓶颈。
- 容易造成阻塞： 一个线程持有锁的时间越长，其他线程等待的时间就越长。
第三幕：细粒度锁，精细化的管理
细粒度锁，就好比小区里每个楼栋都有自己的保安，只管自己楼栋的出入口。这样，不同楼栋的居民就可以同时进出，互不干扰，效率自然就高了。
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <algorithm>
class FineGrainedDataStructure {
public:
FineGrainedDataStructure(int size) : data_(size) {
mutexes_.resize(size); // 为每个元素创建一个锁
}
void set_data(int index, int data) {
std::lock_guard<std::mutex> lock(mutexes_[index]); // 只锁住特定索引的元素
data_[index] = data;
}
int get_data(int index) {
std::lock_guard<std::mutex> lock(mutexes_[index]);
return data_[index];
}
private:
std::vector<int> data_;
std::vector<std::mutex> mutexes_;
};
int main() {
FineGrainedDataStructure data_structure(100);
std::thread t1([&]() {
for (int i = 0; i < 50; ++i) {
data_structure.set_data(i, i * 2);
}
});
std::thread t2([&]() {
for (int i = 50; i < 100; ++i) {
data_structure.set_data(i, i * 3);
}
});
t1.join();
t2.join();
//验证结果
for (int i = 0; i < 100; ++i) {
std::cout << "data[" << i << "]: " << data_structure.get_data(i) << std::endl;
}
return 0;
}在这个例子里，FineGrainedDataStructure 为 data_ 里的每个元素都配备了一个锁。这意味着，两个线程可以同时修改 data_ 里的不同元素，只要它们不访问同一个元素即可。这样就大大提高了并发度。
细粒度锁的优点：
- 并发度高： 多个线程可以同时访问共享资源的不同部分，提高性能。
- 减少阻塞： 线程只需要锁定它们需要访问的部分，减少了等待时间。
细粒度锁的缺点：
- 实现复杂： 需要更仔细地设计锁的策略，容易出错。
- 开销增加： 需要更多的锁，增加了内存开销，以及锁的管理开销。
- 可能导致死锁： 多个线程以不同的顺序请求多个锁时，可能导致死锁。
第四幕：锁粒度的选择，没有银弹
那么，问题来了，到底该选择粗粒度锁还是细粒度锁呢？ 答案是：没有银弹！
选择哪种锁，取决于你的具体场景，需要权衡利弊。
| 特性 | 粗粒度锁 | 细粒度锁 |
|---|---|---|
| 实现难度 | 简单 | 复杂 |
| 并发度 | 低 | 高 |
| 性能 | 低，尤其是在高并发场景下 | 高，尤其是在读多写少的场景下 |
| 资源消耗 | 低，只需要一个锁 | 高，需要多个锁 |
| 适用场景 | 共享资源竞争激烈，或者实现简单性更重要的情况 | 共享资源可以被分解成多个独立的部分，或者需要高并发的场景 |
| 死锁风险 | 低 | 高，需要仔细设计锁的顺序 |
| 代码复杂度 | 低 | 高 |
| 维护难度 | 低 | 高 |
一些选择的原则：
- 先从粗粒度锁开始： 如果你的程序性能还不错，那就没必要一开始就搞复杂的细粒度锁。先用粗粒度锁保证正确性，然后再根据性能瓶颈进行优化。
- 分析你的数据访问模式： 了解你的程序是如何访问共享资源的。如果不同的线程访问的是不同的数据，那就考虑使用细粒度锁。
- 避免过度优化： 细粒度锁虽然能提高并发度，但是也会增加代码的复杂性和维护成本。不要为了提高一点点性能，而牺牲了代码的可读性和可维护性。
- 使用工具进行分析： 可以使用性能分析工具来找出程序的瓶颈，然后针对性地进行优化。
举几个例子：
-
场景一：一个全局的计数器。 只有一个计数器，所有线程都要更新它。 这种情况下，用粗粒度锁就足够了。 你可以用一个
std::mutex来保护这个计数器。 -
场景二：一个大型的哈希表。 哈希表有很多桶（buckets），不同的线程可以同时访问不同的桶。 这种情况下，可以使用细粒度锁。 你可以为每个桶都配备一个锁，这样不同的线程就可以同时访问不同的桶，而不会互相干扰。
-
场景三：一个银行账户系统。 每个账户都有自己的余额，不同的线程可以同时访问不同的账户。 这种情况下，可以使用细粒度锁。 你可以为每个账户都配备一个锁，这样不同的线程就可以同时访问不同的账户，而不会互相干扰。 但是，如果涉及到多个账户之间的转账，就需要考虑使用事务或者更复杂的锁策略，以避免数据不一致。
第五幕：更高级的锁策略
除了粗粒度锁和细粒度锁，还有一些更高级的锁策略，可以进一步提高并发度：
-
读写锁（Read-Write Locks）： 允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。 适用于读多写少的场景。C++17 引入了
std::shared_mutex和std::shared_lock来实现读写锁。 -
自旋锁（Spin Locks）： 线程在等待锁的时候，不会立即进入睡眠状态，而是会不断地尝试获取锁。 适用于锁的持有时间很短的场景。自旋锁可以避免线程切换的开销，但是如果锁的持有时间很长，会导致 CPU 空转，浪费资源。
-
无锁编程（Lock-Free Programming）： 使用原子操作（atomic operations）来实现并发控制，避免使用锁。 无锁编程可以提供更高的并发度，但是实现起来非常复杂，容易出错。
举个读写锁的例子：
#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>
class ReadWriteData {
public:
ReadWriteData(int initial_value) : data_(initial_value) {}
int read_data() {
std::shared_lock<std::shared_mutex> lock(mutex_); // 共享锁：允许多个读者
return data_;
}
void write_data(int new_value) {
std::unique_lock<std::shared_mutex> lock(mutex_); // 独占锁：只允许一个写者
data_ = new_value;
}
private:
int data_;
std::shared_mutex mutex_;
};
int main() {
ReadWriteData data(10);
std::thread reader1([&]() {
for (int i = 0; i < 5; ++i) {
std::cout << "Reader 1: " << data.read_data() << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
});
std::thread reader2([&]() {
for (int i = 0; i < 5; ++i) {
std::cout << "Reader 2: " << data.read_data() << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(150));
}
});
std::thread writer([&]() {
for (int i = 0; i < 3; ++i) {
data.write_data(i * 100);
std::cout << "Writer: " << i * 100 << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
});
reader1.join();
reader2.join();
writer.join();
return 0;
}在这个例子里，ReadWriteData 使用 std::shared_mutex 来实现读写锁。多个线程可以同时调用 read_data 方法，但是只有一个线程可以调用 write_data 方法。
第六幕：总结与展望
今天，我们一起探讨了 C++ 里锁的粒度选择。 粗粒度锁简单易懂，但是并发度低； 细粒度锁并发度高，但是实现复杂。 选择哪种锁，取决于你的具体场景，需要权衡利弊。 记住，没有银弹，只有最适合你的解决方案。
希望今天的讲座能对你有所帮助。 记住，并发编程是一门艺术，需要不断地学习和实践。 祝你在并发编程的道路上越走越远！
谢谢大家！