C++标准库中的锁lock_guard、unique_lock、shared_lock、scoped_lock、recursive_mutex

C++标准库中的锁

std::mutex.lock是我们在C++中比较常见的锁，我们使用std::mutex.lock方法时，同时需要考虑何时使用std:mutex.unlock方法去解锁。如果在复杂的多线程情况下，加锁、解锁的时机很难把握，也不好实现。

RAII原则是所有的资源都必须有管理对象，而资源的申请操作在管理对象的构造函数中进行，而资源的回收则在管理对象的析构函数中进行。

C++新标准提供了lock_guard, unique_lock, shared_lock, 和 scoped_lock四种锁，用于各种复杂情况。这四种锁都是满足RAII风格。

锁

lock_guard

1. lock_guard：这是C++11中一个简单的 RAII（Resource Acquisition Is Initialization）风格的锁，用于在作用域内自动管理互斥量的锁定和解锁。当 lock_guard 对象被创建时，它会自动锁定互斥量，当对象离开作用域时，它会自动解锁互斥量。lock_guard 不支持手动锁定和解锁，也不支持条件变量。

#include 
#include 
#include 

std::mutex mtx;
int shared_data = 0;

void increment() {
	std::lock_guard<std::mutex> lock(mtx);
	++shared_data;
	std::cout << "Incremented shared_data: " << shared_data << std::endl;
}
int main() {
	std::thread t1(increment);
	std::thread t2(increment);

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

	return 0;
}

运行结果：

unique_lock

unique_lock：这是C++11中一个更灵活的锁，它允许手动锁定和解锁互斥量，以及与条件变量一起使用（是lock_guard的进阶版）。与 lock_guard 类似，unique_lock 也是一个 RAII 风格的锁，当对象离开作用域时，它会自动解锁互斥量。unique_lock 还支持延迟锁定、尝试锁定和可转移的锁所有权。

#include 
#include 
#include 
#include 

std::mutex mtx;
std::condition_variable cv;
int shared_data = 0;
bool ready = false;

void increment() {
	std::unique_lock<std::mutex> lock(mtx);
	cv.wait(lock, [] { return ready; });
	++shared_data;
	std::cout << "Incremented shared_data: " << shared_data << std::endl;
}

void set_ready() {
	std::unique_lock<std::mutex> lock(mtx);
	std::cout << "set_ready finish!" << std::endl;
	ready = true;
	cv.notify_all();
}

int main() {
	std::thread t1(increment);
	std::thread t2(increment);
	std::thread t3(set_ready);

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

	return 0;
}

运行结果：

shared_lock

1. shared_lock：C++14引入的锁，这是一个用于共享互斥量（如 std::shared_mutex 或 std::shared_timed_mutex）的锁，允许多个线程同时读取共享数据，但在写入数据时仍然保证互斥。shared_lock 也是一个 RAII 风格的锁，当对象离开作用域时，它会自动解锁共享互斥量。shared_lock 支持手动锁定和解锁，以及尝试锁定。

#include 
#include 
#include 
#include 

std::shared_mutex sh_mtx;
int shared_data = 0;

void read_data() {
	std::shared_lock<std::shared_mutex> lock(sh_mtx);
	std::cout << "Read shared_data: " << shared_data << std::endl;
}

void write_data() {
	std::unique_lock<std::shared_mutex> lock(sh_mtx);
	++shared_data;
	std::cout << "Incremented shared_data: " << shared_data << std::endl;
}

int main() {
	std::thread t1(read_data);
	std::thread t2(write_data);
	std::thread t3(read_data);

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

	return 0;
}

运行结果：

scoped_lock

scoped_lock：这是 C++17 引入的一个新锁，用于同时锁定多个互斥量，以避免死锁。scoped_lock 是一个 RAII 风格的锁，当对象离开作用域时，它会自动解锁所有互斥量。scoped_lock 不支持手动锁定和解锁，也不支持条件变量。它的主要用途是在需要同时锁定多个互斥量时提供简单且安全的解决方案。

#include 
#include 
#include 

std::mutex mtx1;
std::mutex mtx2;
int shared_data1 = 0;
int shared_data2 = 0;

void increment_both() {
    std::scoped_lock lock(mtx1, mtx2);
    ++shared_data1;
    ++shared_data2;
    std::cout << "Incremented shared_data1: " << shared_data1 << ", shared_data2: " << shared_data2 << std::endl;
}

int main() {
    std::thread t1(increment_both);
    std::thread t2(increment_both);

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

    return 0;
}

互斥量

recursive_mutex

使用场景：一个类的不同成员函数之间，存在相互调用的情况， 如果这样的成员函数作为线程的入口函数时，就会出现在成员函数 func1()中对某个互斥量上锁，并且， func1()中调用了成员函数 func2() ，实际上 func2()为了保护成员数据，func2()内部也对同一个互斥量上锁。 在我们对 std::mutex 的使用经验中， 这样的情况，必定会导致未定义的行为，从而导致死锁的产生。

C++标准库为此提供了 std::recursive_mutex 互斥量， 它在具备 std::mutex 的功能之上， 还可以可以支持上面描述的 “对同一个互斥量进行嵌套上锁” 的能力。

std::recursive_mutex是C++标准库中的一个互斥锁类型，允许同一个线程多次锁定同一个互斥锁，而不会导致死锁。每次锁定互斥锁时，都会增加一个计数器。当解锁互斥锁时，计数器减少。只有当计数器为零时，互斥锁才会被释放，其他线程才能锁定它。

#include 
#include 
#include 

std::recursive_mutex mtx;

void print_hello(int n) {
	std::lock_guard<std::recursive_mutex> lock(mtx);
	if (n > 0) {
		std::cout << "Hello, ";
		print_hello(n - 1);
	}
	else {
		std::cout << "world!" << std::endl;
	}
}

int main() {
	std::thread t1(print_hello, 5);
	std::thread t2(print_hello, 3);

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

	return 0;
}

运行结果：

递归运行，同一个线程同一个互斥量的情况可以避免死锁。