哈喽，各位好！今天咱们来聊聊C++锁优化这件磨人的小妖精。锁，这玩意儿，就像你家门锁，保护共享资源不被乱来。但锁用不好，性能就跟便秘一样，卡得你难受。所以，优化锁至关重要！
今天要讲的是三种锁优化技术：自适应自旋锁、排队锁和混合锁。咱们争取用大白话，加上代码，把它们讲透彻。
一、自旋锁：原地转圈圈的倔强少年
想象一下，你想进一扇门，发现门被锁了。一般的做法是：你乖乖地排队，等别人开门。但自旋锁不一样，它是个倔强少年，它会在门前不停地转圈圈，试图开门，直到门开了为止。
原理：
自旋锁的基本思想是，在尝试获取锁失败时，不立即放弃CPU，而是循环检查锁是否可用。如果锁很快就能释放，那么自旋等待比线程切换的开销要小得多。
优点：
- 适用于锁竞争不激烈，持有锁时间短的情况。 线程切换是有开销的，如果锁很快就能释放，自旋等待能避免线程切换的开销。
- 简单直接。 实现起来比较容易。
缺点：
- 浪费CPU资源。 如果锁长时间被占用，自旋等待会一直占用CPU，导致CPU空转，浪费资源。
- 可能导致优先级反转。 高优先级线程可能因为自旋等待低优先级线程释放锁而被阻塞，导致优先级反转。
- 在高竞争环境下性能较差。 大量线程自旋等待同一个锁，会造成严重的CPU竞争，性能反而不如阻塞锁。
代码示例：
#include <iostream>
#include <atomic>
#include <thread>
class SpinLock {
private:
std::atomic_flag lock_flag = ATOMIC_FLAG_INIT;
public:
void lock() {
while (lock_flag.test_and_set(std::memory_order_acquire)) {
// 自旋等待
}
}
void unlock() {
lock_flag.clear(std::memory_order_release);
}
};
SpinLock spin_lock;
int shared_data = 0;
void increment_data() {
for (int i = 0; i < 100000; ++i) {
spin_lock.lock();
shared_data++;
spin_lock.unlock();
}
}
int main() {
std::thread t1(increment_data);
std::thread t2(increment_data);
t1.join();
t2.join();
std::cout << "Shared data: " << shared_data << std::endl; // 期望结果：200000
return 0;
}代码解释：
std::atomic_flag：一个原子布尔标志，用于表示锁的状态。ATOMIC_FLAG_INIT初始化为未锁定状态。lock()：使用test_and_set()原子操作尝试获取锁。如果锁已经被占用，test_and_set()返回true，线程进入自旋等待。如果锁未被占用，test_and_set()将锁设置为占用状态并返回false，线程获取到锁。unlock()：使用clear()原子操作释放锁。
自适应自旋锁：更聪明的倔强少年
普通的自旋锁太死板，不管锁的竞争情况，都一直自旋。自适应自旋锁就聪明多了，它会根据之前的自旋情况，动态调整自旋的时间。
原理：
自适应自旋锁会根据之前锁的获取情况，动态调整自旋的次数或时间。如果上次自旋成功获取到了锁，那么下次自旋时可以增加自旋的次数或时间。如果上次自旋失败了，那么下次自旋时可以减少自旋的次数或时间，甚至直接进入阻塞状态。
优点：
- 性能更好。 能够根据实际情况动态调整自旋策略，减少CPU浪费，提高性能。
- 更灵活。 可以根据不同的应用场景选择不同的自旋策略。
缺点：
- 实现更复杂。 需要维护一些状态信息，并根据这些信息动态调整自旋策略。
- 可能存在抖动。 自旋策略的调整可能会导致性能抖动。
代码示例（简化版）：
#include <iostream>
#include <atomic>
#include <thread>
#include <chrono>
class AdaptiveSpinLock {
private:
std::atomic_flag lock_flag = ATOMIC_FLAG_INIT;
std::atomic<int> spin_count = 100; // 初始自旋次数
public:
void lock() {
int current_spin_count = spin_count.load(std::memory_order_relaxed);
for (int i = 0; i < current_spin_count; ++i) {
if (!lock_flag.test_and_set(std::memory_order_acquire)) {
// 自旋成功
spin_count.store(std::min(current_spin_count + 10, 1000), std::memory_order_relaxed); // 增加自旋次数
return;
}
std::this_thread::yield(); // 让出CPU
}
// 自旋失败，直接尝试获取锁，如果还是失败，则阻塞
while (lock_flag.test_and_set(std::memory_order_acquire)) {
// 自旋失败，降低自旋次数
spin_count.store(std::max(current_spin_count - 10, 10), std::memory_order_relaxed);
std::this_thread::yield();
}
}
void unlock() {
lock_flag.clear(std::memory_order_release);
}
};
AdaptiveSpinLock adaptive_spin_lock;
int shared_data_adaptive = 0;
void increment_data_adaptive() {
for (int i = 0; i < 100000; ++i) {
adaptive_spin_lock.lock();
shared_data_adaptive++;
adaptive_spin_lock.unlock();
}
}
int main() {
std::thread t1(increment_data_adaptive);
std::thread t2(increment_data_adaptive);
t1.join();
t2.join();
std::cout << "Shared data (adaptive): " << shared_data_adaptive << std::endl; // 期望结果：200000
return 0;
}代码解释：
spin_count：一个原子整数，用于记录当前的自旋次数。lock()：首先获取当前的自旋次数，然后进行自旋。如果在自旋过程中成功获取到了锁，则增加自旋次数。如果自旋失败，则降低自旋次数。如果自旋次数降低到一定程度，则直接进入阻塞状态。unlock()：释放锁。
总结：
| 特性 | 自旋锁 | 自适应自旋锁 |
|---|---|---|
| 自旋策略 | 固定自旋 | 动态调整自旋次数/时间 |
| 适用场景 | 短期竞争 | 竞争情况变化 |
| CPU占用 | 可能浪费CPU | 更有效地利用CPU |
| 实现复杂度 | 简单 | 较复杂 |
二、排队锁：先来后到的文明人
自旋锁虽然有自适应的版本，但本质上还是让线程抢锁。如果有很多线程竞争同一个锁，自旋锁的性能会很差。这时候，就需要排队锁出场了。
想象一下，你去银行办业务，人很多。你是直接冲到柜台前抢着办，还是乖乖地排队？排队锁就是让线程乖乖地排队，先来后到，避免了激烈的竞争。
原理：
排队锁维护一个等待队列，当线程尝试获取锁失败时，会将自己加入到等待队列中。当锁被释放时，会唤醒等待队列中的第一个线程。
优点：
- 避免了激烈的竞争。 线程按照先来后到的顺序获取锁，避免了大量线程同时竞争锁的情况。
- 公平性。 保证了线程获取锁的公平性，避免了某些线程一直获取不到锁的情况。
缺点：
- 开销较大。 需要维护一个等待队列，并且在锁释放时唤醒等待队列中的线程，这些操作都有一定的开销。
- 可能存在上下文切换。 线程在等待锁时可能会被挂起，需要进行上下文切换，增加了开销。
常见的排队锁：
- Ticket Lock: 类似银行排号系统。
- CLH Lock: Craig, Landin, and Hagersten lock.
- MCS Lock: Mellor-Crummey and Scott lock.
代码示例 (Ticket Lock):
#include <iostream>
#include <atomic>
#include <thread>
class TicketLock {
private:
std::atomic<int> ticket = 0; // 当前排队号码
std::atomic<int> serve = 0; // 当前服务号码
public:
void lock() {
int my_ticket = ticket.fetch_add(1, std::memory_order_relaxed);
while (serve.load(std::memory_order_acquire) != my_ticket) {
// 自旋等待，直到轮到自己
std::this_thread::yield();
}
}
void unlock() {
serve.fetch_add(1, std::memory_order_release);
}
};
TicketLock ticket_lock;
int shared_data_ticket = 0;
void increment_data_ticket() {
for (int i = 0; i < 100000; ++i) {
ticket_lock.lock();
shared_data_ticket++;
ticket_lock.unlock();
}
}
int main() {
std::thread t1(increment_data_ticket);
std::thread t2(increment_data_ticket);
t1.join();
t2.join();
std::cout << "Shared data (ticket): " << shared_data_ticket << std::endl; // 期望结果：200000
return 0;
}代码解释：
ticket：原子整数，表示当前排队号码。serve：原子整数，表示当前服务号码。lock()：线程首先获取一个排队号码，然后自旋等待，直到轮到自己被服务。unlock()：释放锁，将服务号码加1，通知下一个线程可以获取锁了。
三、混合锁：集百家之长的全能选手
上面说的自旋锁和排队锁各有优缺点，有没有一种锁能集百家之长呢？答案是肯定的，那就是混合锁。
原理：
混合锁结合了自旋锁和排队锁的优点。它首先尝试自旋一段时间，如果自旋成功，则获取锁。如果自旋失败，则将自己加入到等待队列中。
优点：
- 性能更好。 能够根据实际情况选择合适的策略，既能避免线程切换的开销，又能避免激烈的竞争。
- 更灵活。 可以根据不同的应用场景选择不同的自旋时间和等待队列的实现方式。
缺点：
- 实现更复杂。 需要同时维护自旋锁和等待队列，实现起来比较复杂。
- 需要仔细调优。 自旋时间和等待队列的实现方式需要仔细调优，才能达到最佳性能。
代码示例（简化版）：
#include <iostream>
#include <atomic>
#include <thread>
#include <mutex>
#include <condition_variable>
class HybridLock {
private:
std::atomic_flag lock_flag = ATOMIC_FLAG_INIT;
std::mutex mutex;
std::condition_variable cv;
bool locked = false;
public:
void lock() {
// 首先尝试自旋
for (int i = 0; i < 100; ++i) {
if (!lock_flag.test_and_set(std::memory_order_acquire)) {
// 自旋成功
return;
}
std::this_thread::yield();
}
// 自旋失败，加入等待队列
std::unique_lock<std::mutex> ul(mutex);
cv.wait(ul, [&]() { return !locked; }); // 等待锁释放
locked = true;
lock_flag.test_and_set(std::memory_order_acquire); // 获取锁（确保可见性）
}
void unlock() {
lock_flag.clear(std::memory_order_release);
{
std::lock_guard<std::mutex> lg(mutex);
locked = false;
}
cv.notify_one(); // 唤醒等待线程
}
};
HybridLock hybrid_lock;
int shared_data_hybrid = 0;
void increment_data_hybrid() {
for (int i = 0; i < 100000; ++i) {
hybrid_lock.lock();
shared_data_hybrid++;
hybrid_lock.unlock();
}
}
int main() {
std::thread t1(increment_data_hybrid);
std::thread t2(increment_data_hybrid);
t1.join();
t2.join();
std::cout << "Shared data (hybrid): " << shared_data_hybrid << std::endl; // 期望结果：200000
return 0;
}代码解释：
- 首先尝试自旋一段时间，如果自旋成功，则获取锁。
- 如果自旋失败，则使用
std::mutex和std::condition_variable进入等待队列，等待锁释放。 - 释放锁时，先清除
lock_flag，然后通知等待队列中的一个线程。
总结：
| 特性 | 自旋锁 | 排队锁 | 混合锁 |
|---|---|---|---|
| 竞争激烈度 | 低 | 高 | 适中 |
| 线程切换 | 无 | 有 | 视自旋情况而定 |
| 实现复杂度 | 简单 | 较复杂 | 复杂 |
| 适用场景 | 短期竞争 | 长时间竞争 | 各种竞争情况 |
锁的选择：一把钥匙开一把锁
选择哪种锁，没有绝对的答案，要根据具体的应用场景来选择。
- 锁竞争不激烈，持有锁时间短： 自旋锁。
- 锁竞争激烈，持有锁时间长： 排队锁。
- 竞争情况不确定，需要兼顾性能和公平性： 混合锁。
其他优化建议：
- 减少锁的粒度。 尽量将锁的范围缩小，减少锁的竞争。
- 避免持有锁的时间过长。 尽量在持有锁的时间内只做必要的操作。
- 使用读写锁。 如果读操作远多于写操作，可以使用读写锁，允许多个线程同时读取共享资源。
- 考虑无锁数据结构。 在某些情况下，可以使用无锁数据结构来避免锁的使用。
总结的总结：
锁优化是一门大学问，需要不断学习和实践。希望今天的讲解能帮助大家更好地理解C++锁优化技术，写出高性能的并发程序。记住，没有银弹，只有根据场景选择最合适的方案。
好了，今天的分享就到这里，谢谢大家！