C++学习之路之线程锁

参考链接：https://zhuanlan.zhihu.com/p/600270985
1、互斥锁（mutex）
互斥锁用于保护临界区（一段需要互斥访问的代码）。当一个线程获得了互斥锁后，其他试图获取该互斥锁的线程将被阻塞，直到互斥锁被释放。互斥锁的常用操作包括上锁（lock）和解锁（unlock）。
语法：

#include <mutex>

std::mutex mtx;  // 定义互斥锁

// 在临界区之前加锁
mtx.lock();

// 临界区代码

// 在临界区之后解锁
mtx.unlock();

2、递归锁（recursive_mutex）
递归锁类似于互斥锁，但允许同一线程多次获取锁，而不会导致死锁。递归锁的常用操作与互斥锁类似。
语法：

#include <mutex>

std::recursive_mutex mtx;  // 定义递归锁

// 在临界区之前加锁
mtx.lock();

// 递归调用
otherFunction();

// 在临界区之后解锁
mtx.unlock();

3、读写锁（shared_mutex）：
读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。这种锁更适用于读多写少的场景。读写锁的常用操作包括上读锁（lock_shared）、上写锁（lock）和解锁（unlock）。
语法：

#include <shared_mutex>

std::shared_mutex mtx;  // 定义读写锁

// 在读取共享资源之前加读锁
mtx.lock_shared();

// 读取共享资源

// 在读取共享资源之后解读锁
mtx.unlock_shared();

// 在修改共享资源之前加写锁
mtx.lock();

// 修改共享资源

// 在修改共享资源之后解写锁
mtx.unlock();

4、条件变量（condition_variable）：
条件变量用于线程之间的通信，当某个线程等待特定条件成立时，可以通过条件变量暂停当前线程的执行，并唤醒其他等待的线程。条件变量的常用操作包括等待（wait）、通知一个线程（notify_one）和通知所有线程（notify_all）。
语法：

#include <condition_variable>

std::mutex mtx;  // 定义互斥锁
std::condition_variable cv;  // 定义条件变量

// 线程1
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock);  // 等待条件成立
// 执行其他操作

// 线程2
{
    std::lock_guard<std::mutex> lock(mtx);
    // 唤醒一个等待的线程
    cv.notify_one();
    // 或者唤醒所有等待的线程
    cv.notify_all();
}

其中：
1、

std::lock_guard<std::mutex> 

std::lock_guardstd::mutex 是一个C++标准库提供的RAII（Resource Acquisition Is Initialization）风格的类模板，用于简化互斥锁的上锁和解锁操作。

std::lock_guardstd::mutex 对象在创建时会尝试获取所关联的互斥锁的所有权，并在其生命周期中保持锁的状态。当 std::lock_guard 对象离开作用域时（例如函数返回或代码块结束），它会自动释放互斥锁的所有权，从而实现了互斥锁的自动解锁。

std::lock_guard 的作用在于简化代码的编写，避免忘记手动调用 unlock，从而减少了因忘记解锁而导致的潜在问题，例如死锁。

下面是一个示例，演示了使用 std::lock_guard 对互斥锁进行上锁和解锁操作：

#include <mutex>

std::mutex mtx;  // 定义互斥锁

void function()
{
    std::lock_guard<std::mutex> lock(mtx);  // 上锁

    // 互斥锁保护的临界区代码
    // ...

    // 当 lock_guard 对象离开作用域时，
    // 互斥锁会自动解锁
}

在上述示例中，通过创建 std::lock_guardstd::mutex 对象并将互斥锁作为构造函数的参数传递给它，实现了互斥锁的上锁。当 lock_guard 对象离开作用域时，析构函数会被调用，自动释放互斥锁，实现了互斥锁的解锁。

因此，std::lock_guardstd::mutex 的作用就是在构造时获取互斥锁的所有权，在析构时释放互斥锁的所有权，从而简化了互斥锁的上锁和解锁操作。
2、

std::unique_lock<std::mutex>

std::unique_lockstd::mutex 是C++标准库中另一个用于互斥锁管理的类模板，与 std::lock_guard 类似，也是用于简化互斥锁的上锁和解锁操作，并提供更灵活的锁管理方式。

与 std::lock_guard 的最大区别在于，std::unique_lock 具有更多的灵活性和可配置性。下面是 std::unique_lock 的一些主要特点和作用：

更灵活的上锁和解锁控制：std::unique_lock 允许在需要的时候手动上锁和解锁互斥锁。与 std::lock_guard 自动上锁和析构时自动解锁不同，std::unique_lock 提供了 lock() 和 unlock() 方法分别用于手动控制互斥锁的上锁和解锁，这使得可以根据实际需要动态地控制锁的状态。

延迟锁定和递归锁定：std::unique_lock 允许延迟锁定（deferred locking）和递归锁定（recursive locking）的操作。延迟锁定指的是在创建 std::unique_lock 对象时不立即上锁，而是在后续的某个时刻手动调用 lock() 方法来上锁。递归锁定指的是同一个线程可以多次获得同一个互斥锁的所有权。

可移动和可交换：std::unique_lock 对象是可移动（movable）和可交换（swappable）的，可以方便地在拥有互斥锁的线程之间传递或交换所有权。

下面是一个示例，展示了 std::unique_lock 的一些使用方式：

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

std::mutex mtx;  // 定义互斥锁

void printMessage(const std::string& message)
{
    std::unique_lock<std::mutex> lock(mtx);  // 上锁

    for (int i = 0; i < 5; ++i)
    {
        std::cout << message << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

    // lock.unlock(); // 可以手动解锁

    // 延迟上锁
    // lock.lock();

    // 递归锁定
    // lock.lock();
    // ...
    // lock.unlock();

    // 当 unique_lock 对象离开作用域时，
    // 互斥锁会自动解锁
}

int main()
{
    std::thread t1(printMessage, "Hello");
    std::thread t2(printMessage, "World");

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

    return 0;
}

在上述示例中，通过创建两个线程，分别调用 printMessage 函数，并传递不同的消息作为参数。在 printMessage 函数中，通过创建 std::unique_lockstd::mutex 对象并将互斥锁作为构造函数的参数传递给它，实现了互斥锁的上锁。通过调用 lock() 方法，可以手动上锁，并且可以通过 unlock() 方法手动解锁。另外，通过注释掉的代码，展示了延迟锁定和递归锁定的用法。

总结来说，std::unique_lockstd::mutex 提供了更灵活的互斥锁管理方式，允许手动上锁和解锁、延迟锁定和递归锁定等操作。它的使用相对复杂一些，但可以根据实际需求进行更细粒度地控制。