云计算百科
云计算领域专业知识百科平台

C++ 管理互斥量锁所有权 std::lock_guard、std::unique_lock、std::shared_lock、std::scoped_lock

C++ 管理互斥量锁所有权 std::lock_guard、std::unique_lock、std::shared_lock、std::scoped_lock

flyfish

一、lock_guard:最简单的作用域保护

演示多线程并发累加一个全局计数器,用 lock_guard 保护临界区。

#include <iostream>
#include <thread>
#include <mutex>

long counter = 0;
std::mutex mtx;

void increment(int n) {
for (int i = 0; i < n; i++) {
std::lock_guard<std::mutex> guard(mtx);
counter++;
}
}

int main() {
std::thread t1(increment, 100000);
std::thread t2(increment, 100000);
t1.join();
t2.join();
std::cout << "counter = " << counter << std::endl;
return 0;
}

输出

counter = 200000

lock_guard 在进入 for 循环体的时候构造,调用 mtx.lock(),在循环体结束、离开花括号的时候析构,调用 mtx.unlock()。每一轮循环加锁一次、解锁一次,粒度刚好包住 counter++ 这一行。

它的特点是完全不能干预锁的过程。构造完就拿着锁,中间没有任何接口提前解锁,也不能把锁转移给别人。这种严格反而是优点:代码意图非常清晰,就是这段代码必须互斥执行,没有多余的灵活度,也就不会出错。

二、unique_lock:配合条件变量做线程等待通知

演示一个经典的生产者消费者队列:一个线程往队列放数据,另一个线程从队列取数据,队列为空时消费者阻塞等待,生产者放入数据后唤醒消费者。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

std::queue<int> q;
std::mutex mtx;
std::condition_variable cv;

void producer() {
for (int i = 1; i <= 5; i++) {
{
std::unique_lock<std::mutex> lock(mtx);
q.push(i);
std::cout << "produced " << i << std::endl;
}
cv.notify_one();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}

void consumer() {
for (int i = 0; i < 5; i++) {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [](){ return !q.empty(); });
int val = q.front();
q.pop();
std::cout << "consumed " << val << std::endl;
}
}

int main() {
std::thread t1(producer);
std::thread t2(consumer);
t1.join();
t2.join();
return 0;
}

输出

produced 1
consumed 1
produced 2
consumed 2
produced 3
consumed 3
produced 4
consumed 4
produced 5
consumed 5

关键在 cv.wait(lock, …) 这一行。这个函数做三件事:先把当前线程挂起,然后临时释放 mutex,让生产者线程能拿到锁往队列里放数据;等被 notify 唤醒后,再重新获取 mutex,然后检查条件是否满足,不满足就继续挂起。

这个"等待时释放锁、唤醒后重新拿锁"的过程,要求锁包装器必须支持手动解锁和重新加锁,还要能记录当前是否持有锁。lock_guard 做不到,因为它一旦构造就锁死,中间没有接口让 wait 函数把锁解开。而 unique_lock 提供了 unlock() 和重新 lock() 的能力,内部还有一个标志位记录锁的持有状态,条件变量的 wait 函数正是依赖这些接口工作的。

这就是为什么 C++ 标准规定 condition_variable::wait 只接受 unique_lock<std::mutex>,不接受 lock_guard。unique_lock 的灵活性不是多余的,而是条件变量机制本身就需要它。

C++ 管理互斥量锁所有权 std::unique_lock 代码解释

三、shared_lock:读写分离的共享数据保护

演示一个多读者单写者的缓存场景。多个线程可以同时读缓存内容,但当一个线程要写缓存时,必须独占,不能和其他读或写同时进行。

#include <iostream>
#include <thread>
#include <mutex>
#include <shared_mutex>
#include <chrono>
#include <string>

std::shared_mutex cache_mtx;
int cache_value = 0;
std::mutex print_mtx;

void log(const std::string& msg) {
std::lock_guard<std::mutex> guard(print_mtx);
std::cout << msg << std::endl;
}

void reader(int id) {
for (int i = 0; i < 3; i++) {
std::shared_lock<std::shared_mutex> lock(cache_mtx);
log("reader " + std::to_string(id) + " reads value = " + std::to_string(cache_value));
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
}

void writer(int id) {
for (int i = 0; i < 3; i++) {
std::unique_lock<std::shared_mutex> lock(cache_mtx);
cache_value++;
log("writer " + std::to_string(id) + " writes value = " + std::to_string(cache_value));
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}

int main() {
std::thread r1(reader, 1);
std::thread r2(reader, 2);
std::thread r3(reader, 3);
std::thread w1(writer, 1);
r1.join();
r2.join();
r3.join();
w1.join();
return 0;
}

注意读线程用的是 shared_lock,写线程用的是 unique_lock,两者保护的是同一个 std::shared_mutex。

shared_lock 构造时调用的不是 lock(),而是 lock_shared()。这个调用的含义是"我要读,多个读者可以同时进来"。只要当前没有写者持有锁,多个 shared_lock 可以同时成功,读操作真正并行执行。

而写线程的 unique_lock 调用的是普通的 lock(),含义是"我要写,所有人都得让开"。写者拿到锁的时候,所有读线程都必须等写者释放后才能继续。

为什么不能用普通的 lock_guard 或 unique_lock 来保护读操作?因为那样读线程之间也会互斥,读多写少的场景下性能会很差。shared_lock 的价值就是把"读"和"写"区分开,读操作共享并行,写操作独占串行。

这也是 std::shared_mutex 和普通 std::mutex 的本质区别:普通 mutex 不管读写都独占,shared_mutex 区分读共享和写独占。

C++ 管理互斥量锁所有权 std::shared_lock 代码解释

四、scoped_lock:同时持有多把锁避免死锁

这个例子演示两个银行账户之间转账。转账操作需要同时锁住转出账户和转入账户,两个方向的转账同时发生时,如果按顺序加锁就会死锁。

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <string>

struct Account {
int balance;
std::mutex mtx;
};

std::mutex print_mtx;

void log(const std::string& msg) {
std::lock_guard<std::mutex> guard(print_mtx);
std::cout << msg << std::endl;
}

void transfer(Account& from, Account& to, int amount) {
std::scoped_lock<std::mutex, std::mutex> lock(from.mtx, to.mtx);
from.balance -= amount;
to.balance += amount;
log("transfer " + std::to_string(amount) + " done, from balance = "
+ std::to_string(from.balance) + ", to balance = "
+ std::to_string(to.balance));
}

int main() {
Account a{ 100, {} };
Account b{ 100, {} };

std::thread t1(transfer, std::ref(a), std::ref(b), 50);
std::thread t2(transfer, std::ref(b), std::ref(a), 30);

t1.join();
t2.join();

std::scoped_lock<std::mutex, std::mutex> final_lock(a.mtx, b.mtx);
log("final: a.balance = " + std::to_string(a.balance)
+ ", b.balance = " + std::to_string(b.balance));

return 0;
}

输出

transfer 50 done, from balance = 50, to balance = 150
transfer 30 done, from balance = 120, to balance = 80
final: a.balance = 80, b.balance = 120

scoped_lock 接收了两个互斥量:from.mtx 和 to.mtx。它在构造的时候,内部用 std::lock 的死锁避免算法把这两个锁一次性全部拿到,而不是简单地先锁 from 再锁 to。

为什么这很重要?假设不用 scoped_lock,你自己写:

std::lock_guard<std::mutex> l1(from.mtx);
std::lock_guard<std::mutex> l2(to.mtx);

当 t1 从 a 转 b 时,它先锁 a.mtx 再锁 b.mtx。当 t2 从 b 转 a 时,它先锁 b.mtx 再锁 a.mtx。两个线程各拿一把锁,互相等对方手里的那把,就死锁了。

scoped_lock 内部的做法是,它不会固定按传入顺序加锁,而是用一种避免死锁的策略(通常是尝试锁定、失败就回退换顺序,或者按地址排序)来确保多个线程不管以什么顺序传入这两个锁,都不会出现循环等待。

它和 lock_guard 的行为很像:构造即锁定全部,析构即解锁全部,中途不能操作。区别只是它能同时包多个互斥量,并且内部处理了多锁的死锁问题。C++17 之前,你需要手动用 std::lock 加锁再配合 lock_guard 的 adopt_lock 参数来实现同样的效果,scoped_lock 把这个流程打包成了一个更简洁的接口。

差异对照

维度lock_guardunique_lockshared_lockscoped_lock
一次管理几个锁 1 个 1 个 1 个 任意多个
中途能否手动解锁 不能 能 能 不能
能否转移锁所有权 不能 能(移动) 能(移动) 不能
锁的类型 独占写锁 独占写锁 共享读锁 多把独占写锁
典型搭档 简单临界区 条件变量 shared_mutex 读侧 多对象同时加锁
标准版本 C++11 C++11 C++14 C++17

赞(0)
未经允许不得转载:网硕互联帮助中心 » C++ 管理互斥量锁所有权 std::lock_guard、std::unique_lock、std::shared_lock、std::scoped_lock
分享到: 更多 (0)

评论 抢沙发

评论前必须登录!