哈喽，各位好！今天我们要聊聊C++17中一个非常实用的小工具，std::scoped_lock。 它的主要职责就是：同时锁定多个互斥量，避免死锁，让你的多线程程序不再提心吊胆。
死锁是什么鬼？
在深入scoped_lock之前，我们先来聊聊死锁。死锁就像两个熊孩子抢玩具，一个抱着变形金刚不撒手，另一个抱着奥特曼不松爪。 两人都想要对方的玩具，但谁也不肯先放手，结果谁也玩不成。
在多线程编程中，死锁通常发生在多个线程需要访问多个共享资源（互斥量）时。 如果线程以不同的顺序请求这些资源，就可能出现循环等待的情况，造成死锁。
举个栗子：
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mutex1;
std::mutex mutex2;
void thread1() {
mutex1.lock();
std::cout << "Thread 1: Locked mutex1" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟一些操作
mutex2.lock();
std::cout << "Thread 1: Locked mutex2" << std::endl;
// 访问共享资源
std::cout << "Thread 1: Accessing shared resources" << std::endl;
mutex2.unlock();
mutex1.unlock();
}
void thread2() {
mutex2.lock();
std::cout << "Thread 2: Locked mutex2" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟一些操作
mutex1.lock();
std::cout << "Thread 2: Locked mutex1" << std::endl;
// 访问共享资源
std::cout << "Thread 2: Accessing shared resources" << std::endl;
mutex1.unlock();
mutex2.unlock();
}
int main() {
std::thread t1(thread1);
std::thread t2(thread2);
t1.join();
t2.join();
return 0;
}在这个例子中，thread1先锁mutex1，再锁mutex2，而thread2先锁mutex2，再锁mutex1。 如果thread1锁定了mutex1，thread2锁定了mutex2，那么它们就会互相等待对方释放锁，造成死锁。 运行这个程序，很有可能就卡住了。
std::scoped_lock：救星来了！
std::scoped_lock就是为了解决这个问题而生的。 它可以同时锁定多个互斥量，并且保证以一种避免死锁的顺序进行锁定（通常是按照互斥量地址的顺序，但具体实现可能不同，你不用太关心这个细节）。 最重要的是，当scoped_lock对象离开作用域时，它会自动释放所有锁定的互斥量，即使发生异常也不怕。
用人话说，scoped_lock就像一个智能管家，你告诉它要锁哪些房间，它会自动帮你把门都锁好，并且在你离开的时候，自动帮你把门都打开，防止你被锁在里面。
scoped_lock怎么用？
使用scoped_lock非常简单，只需要包含头文件 <mutex>，然后创建一个scoped_lock对象，并将要锁定的互斥量作为参数传递给它即可。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mutex1;
std::mutex mutex2;
void thread1() {
std::scoped_lock lock(mutex1, mutex2); // 同时锁定 mutex1 和 mutex2
std::cout << "Thread 1: Locked mutex1 and mutex2" << std::endl;
// 访问共享资源
std::cout << "Thread 1: Accessing shared resources" << std::endl;
// scoped_lock 会在离开作用域时自动释放锁
}
void thread2() {
std::scoped_lock lock(mutex1, mutex2); // 同时锁定 mutex1 和 mutex2
std::cout << "Thread 2: Locked mutex1 and mutex2" << std::endl;
// 访问共享资源
std::cout << "Thread 2: Accessing shared resources" << std::endl;
// scoped_lock 会在离开作用域时自动释放锁
}
int main() {
std::thread t1(thread1);
std::thread t2(thread2);
t1.join();
t2.join();
return 0;
}在这个例子中，我们使用std::scoped_lock lock(mutex1, mutex2);同时锁定了mutex1和mutex2。 scoped_lock会保证以一种避免死锁的顺序锁定这两个互斥量，并且在lock对象离开作用域时，自动释放这两个互斥量。 这样就避免了死锁的发生。
scoped_lock的优势
- 避免死锁: 这是
scoped_lock最主要的功能，它可以保证以一种避免死锁的顺序锁定多个互斥量。 - 异常安全: 即使在锁定互斥量之后，访问共享资源的代码抛出异常，
scoped_lock也会在析构时自动释放所有锁定的互斥量，避免资源泄漏。 - 简化代码: 使用
scoped_lock可以避免手动锁定和解锁互斥量，使代码更加简洁易懂。
scoped_lock vs std::lock_guard
你可能听说过std::lock_guard，它也是一个 RAII 锁管理器，但它只能锁定一个互斥量。 scoped_lock可以看作是lock_guard的增强版，它可以同时锁定多个互斥量。
| 特性 | std::lock_guard |
std::scoped_lock |
|---|---|---|
| 锁定互斥量数量 | 1 | 多个 |
| 避免死锁 | 不能 | 可以 |
| C++标准 | C++11 | C++17 |
scoped_lock的更多用法
scoped_lock可以接受任意数量的互斥量作为参数。 例如，如果你需要同时锁定三个互斥量，可以这样写：
std::mutex mutex1;
std::mutex mutex2;
std::mutex mutex3;
void some_function() {
std::scoped_lock lock(mutex1, mutex2, mutex3);
// 访问共享资源
}scoped_lock还可以接受std::adopt_lock作为参数。 std::adopt_lock表示互斥量已经被当前线程锁定，scoped_lock只是接管了互斥量的所有权，并在析构时释放它。 这种情况通常发生在已经使用lock()方法手动锁定了互斥量，然后希望使用scoped_lock来管理互斥量的释放。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mutex1;
void some_function() {
mutex1.lock();
std::scoped_lock lock(mutex1, std::adopt_lock); // 接管 mutex1 的所有权
std::cout << "Locked mutex1" << std::endl;
// 访问共享资源
// lock 会在离开作用域时自动释放 mutex1
}
int main() {
std::thread t1(some_function);
t1.join();
return 0;
}注意事项
- 避免过度锁定: 尽量只在必要的时候才锁定互斥量，并且尽量缩短锁定时间。 过度锁定会降低程序的并发性能。
- 小心嵌套锁定: 尽量避免嵌套锁定互斥量。 如果必须进行嵌套锁定，要确保以相同的顺序锁定互斥量，避免死锁。 更好的做法是，尽量将需要多个锁的代码块提取出来，用一个
scoped_lock一次性锁定所有需要的互斥量。 - 不要在
scoped_lock的作用域内调用可能抛出异常的代码: 虽然scoped_lock保证在析构时释放互斥量，但如果在构造scoped_lock对象之前，或者在scoped_lock的作用域内抛出异常，可能会导致互斥量没有被正确锁定或释放。 建议使用 try-catch 块来处理可能抛出异常的代码。
一个更复杂的例子
假设我们有一个银行账户类，它有两个互斥量：一个用于保护账户余额，另一个用于保护交易记录。
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
class BankAccount {
public:
BankAccount(int balance) : balance_(balance) {}
void deposit(int amount) {
std::scoped_lock lock(balance_mutex_, transaction_mutex_); // 同时锁定余额和交易记录
balance_ += amount;
transactions_.push_back("Deposit: " + std::to_string(amount));
std::cout << "Deposit: " << amount << ", Balance: " << balance_ << std::endl;
}
void withdraw(int amount) {
std::scoped_lock lock(balance_mutex_, transaction_mutex_); // 同时锁定余额和交易记录
if (balance_ >= amount) {
balance_ -= amount;
transactions_.push_back("Withdraw: " + std::to_string(amount));
std::cout << "Withdraw: " << amount << ", Balance: " << balance_ << std::endl;
} else {
std::cout << "Insufficient funds" << std::endl;
}
}
void print_transactions() {
std::scoped_lock lock(transaction_mutex_); // 只锁定交易记录
std::cout << "Transactions:" << std::endl;
for (const auto& transaction : transactions_) {
std::cout << transaction << std::endl;
}
}
private:
int balance_;
std::mutex balance_mutex_;
std::vector<std::string> transactions_;
std::mutex transaction_mutex_;
};
int main() {
BankAccount account(100);
std::thread t1([&]() {
for (int i = 0; i < 10; ++i) {
account.deposit(10);
}
});
std::thread t2([&]() {
for (int i = 0; i < 10; ++i) {
account.withdraw(5);
}
});
t1.join();
t2.join();
account.print_transactions();
return 0;
}在这个例子中，deposit和withdraw方法需要同时锁定balance_mutex_和transaction_mutex_，以保证账户余额和交易记录的一致性。 print_transactions方法只需要锁定transaction_mutex_，因为它只访问交易记录。 使用scoped_lock可以方便地同时锁定多个互斥量，并避免死锁。
总结
std::scoped_lock是一个非常方便的工具，它可以帮助你轻松地锁定多个互斥量，避免死锁，并简化多线程代码。 记住它的优点：避免死锁、异常安全、简化代码。 在需要同时锁定多个互斥量的时候，scoped_lock绝对是你的好帮手。
希望今天的讲解对你有所帮助！ 多线程编程虽然复杂，但只要掌握了正确的工具和技巧，就能写出高效、稳定的并发程序。 记住，scoped_lock是你的秘密武器之一！ 下次再见！