std::thread进阶同步课：std::unique_lock与std::shared_lock的高级运用

# 1. std::thread与并发基础知识

本章将为您奠定C++11并发编程的基础，并引入`std::thread`类，它是C++11标准库提供的用于创建和管理线程的主要工具。我们将从线程的基本创建和运行开始，逐步过渡到线程间的基本同步机制。

## 1.1 线程的创建与启动

在C++中，线程的创建一般通过`std::thread`的构造函数完成，可以接受一个函数指针、函数对象或可调用对象作为线程的入口点。以下是一个简单的例子：

#include <thread>
#include <iostream>

void printHello() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(printHello);
    t.join(); // 等待线程执行完毕
    return 0;
}

## 1.2 线程间的数据竞争与同步

在多线程程序中，数据竞争是一个常见问题，当多个线程试图同时修改同一数据时，就可能发生。为了防止数据竞争，C++提供了多种同步机制，例如互斥量(`std::mutex`)。下面是一个使用互斥量避免数据竞争的示例：

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

int sharedData = 0;
std::mutex mtx; // 创建一个互斥锁

void increment(int threadId) {
    for (int i = 0; i < 1000; ++i) {
        mtx.lock(); // 上锁
        ++sharedData;
        mtx.unlock(); // 解锁
    }
}

int main() {
    std::thread t1(increment, 1);
    std::thread t2(increment, 2);
    t1.join();
    t2.join();
    std::cout << "Shared data: " << sharedData << std::endl;
    return 0;
}

通过这一章节，您将了解如何在C++11中创建和管理线程，并认识到线程同步的重要性。下一章节将继续深入探讨`std::unique_lock`的高级特性，为并发编程提供更为灵活的同步手段。

# 2. std::unique_lock深入剖析

### 2.1 std::unique_lock的特性与优势

#### 2.1.1 std::unique_lock与std::lock_guard对比

std::unique_lock是C++11引入的一种灵活的互斥锁管理器，相较于早期的std::lock_guard，它提供了一些增强的特性。std::unique_lock通常用于更复杂的场景，其中需要显式锁定和解锁，或者需要将锁的所有权从一个作用域迁移到另一个作用域。

下面是std::unique_lock与std::lock_guard的一些关键对比：

- **灵活性**: std::unique_lock提供了更高级别的灵活性，允许推迟锁定操作到构造函数之外，或者在某个点释放锁，并且可以重新锁定。std::lock_guard在构造时锁定，在析构时解锁，锁定操作是即时且不可改变的。
- **所有权传递**: std::unique_lock支持锁的所有权移动，可以将锁的所有权从一个unique_lock对象传递给另一个，这对于锁的条件变量的等待和通知操作非常有用。

- **自定义锁定策略**: std::unique_lock支持延迟锁定机制，并允许编写自定义的锁定策略，这对于需要精确控制锁定时机的高级用例是必需的。

- **条件变量**: std::unique_lock是唯一能够与std::condition_variable一起使用的互斥锁类型，因为它允许锁在等待条件变量时被释放并在醒来时重新获取。

### 2.1.2 std::unique_lock的延迟锁定机制

std::unique_lock通过延迟锁定来提供更精细的控制，这意味着你可以选择在构造函数中不立即锁定资源。这种特性在需要先进行一些操作（这些操作不应该持有锁），然后再锁定资源时非常有用。例如，可能需要先检查一些条件，如果条件满足，则锁定资源。

延迟锁定是通过在std::unique_lock对象的构造函数中传递`defer_lock`标志来实现的：

#include <mutex>

std::mutex my_mutex;
std::unique_lock<std::mutex> my_lock(my_mutex, std::defer_lock);

在上面的代码中，我们创建了一个`std::unique_lock`对象`my_lock`，但并没有立即锁定`my_mutex`。我们可以在需要的时候调用`my_lock.lock()`来锁定互斥锁，或者使用`my_lock.try_lock()`或`my_lock.unlock()`进行更细粒度的控制。在适当的时候，例如不再需要访问被保护的资源时，应调用`unlock()`方法来释放锁。

### 2.2 std::unique_lock的高级用法

#### 2.2.1 使用std::unique_lock实现自定义锁定策略

std::unique_lock可以用来实现自定义的锁定策略。在某些情况下，标准的锁定机制可能不足以满足特定的需求，比如需要在获取锁之后立即进行特定的操作，或者需要在锁定与解锁之间插入其他逻辑。

自定义锁定策略的实现通常依赖于std::unique_lock的灵活性，包括其提供的`lock()`, `unlock()`, 和 `try_lock()`方法。这些方法可以在try_lock()检查到竞争条件时，或者在需要特定条件满足时才能继续执行时，被用来编写自定义逻辑。

考虑一个自定义锁定策略的例子，其中我们只在工作线程不是忙碌时才尝试获取锁：

#include <mutex>
#include <thread>

std::mutex my_mutex;
std::unique_lock<std::mutex> my_lock(my_mutex, std::defer_lock);
bool is_not_busy = false;

// 检查是否不忙碌
if (/* 某种机制来检查线程不忙碌 */) {
    is_not_busy = true;
    // 在成功获取锁之后，我们可以执行需要锁保护的代码
    if (my_lock.try_lock()) {
        // 处理需要同步访问的数据
        my_lock.unlock(); // 使用完毕后解锁
    }
}

在这个例子中，我们没有使用`lock()`方法直接尝试锁定，而是使用了`try_lock()`方法。这允许我们只在条件满足时锁定资源，例如，当线程不是忙碌状态时。

#### 2.2.2 结合条件变量使用std::unique_lock

std::unique_lock通常与条件变量结合使用，以实现生产者-消费者模型或协调多线程之间的操作。条件变量等待操作需要能够释放锁并且在等待结束时重新获取锁，std::unique_lock正好提供了这样的功能。

当使用std::condition_variable时，必须与std::unique_lock一起使用，因为条件变量需要一个互斥锁来管理访问。下面是一个如何结合std::unique_lock和std::condition_variable的例子：

#include <mutex>
#include <condition_variable>
#include <thread>
#include <chrono>

std::mutex m;
std::condition_variable cv;
int ready = 0;

void print_id(int id) {
    std::unique_lock<std::mutex> lk(m);
    while (!ready) {
        // 在等待时，lk会释放锁，当cv.wait被调用时
        cv.wait(lk);
    }
    // ... 打印输出
}

void go() {
    std::unique_lock<std::mutex> lk(m);
    ready = 1;
    // 通知所有等待线程
    cv.notify_all();
}

int main() {
    std::thread threads[10];
    // 启动10个线程
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(print_id, i);

    std::cout << "10 threads ready to race...\n";
    go(); // 开始比赛

    for (auto& th : threads) th.join();
}

在上述代码中，我们创建了一个条件变量`cv`和一个互斥锁`m`。`print_id`函数负责等待直到`ready`变量被设置为1，而`go`函数则设置`ready`变量并通知所有等待的线程。这里的关键点是`unique_lock`在调用`cv.wait(lk)`时，它会自动释放锁，从而避免了潜在的死锁情况，并在等待的线程被唤醒后自动重新获取锁。

### 2.3 std::unique_lock性能优化技巧

#### 2.3.1 锁粒度与死锁避免

在使用std::unique_lock等互斥锁时，合理选择锁的粒度是非常关键的。锁的粒度指的是受保护的资源的大小，过细的锁粒度会导致过多的锁竞争，而过粗的锁粒度会导致不必要的等待，从而降低了并发性能。

死锁是多线程编程中一个常见的问题，它发生在多个线程相互等待对方释放资源的情况下。为了避免死锁，可以采取以下措施：

- **避免嵌套锁**: 尽量避免在持有一个锁的情况下再去尝试获取另一个锁。
- **固定顺序获取锁**: 如果不得不同时持有多把锁，确保所有线程都以相同的顺序获取这些锁。
- **使用锁超时**: 使用`try_lock_for`和`try_lock_until`方法为锁尝试加上时间限制，防止线程长时间等待。

#### 2.3.2 锁的迁移与所有权传递

std::unique_lock允许锁的所有权在多个对象之间传递，这提供了极大的灵活性。当需要将锁的所有权从一个函数转移到另一个函数时，可以使用std::move来实现。

锁的所有权迁移允许更精细地控制锁的生命周期，特别是在复杂的同步场景中。例如，在一个函数中尝试获取锁，然后需要将锁传递到另一个函数中执行实际操作。

void handle_data(std::unique_lock<std::mutex>& lk, /* 其他参数 */) {
    // 在这个函数中处理数据
}

void process_data() {
    std::mutex m;
    std::unique_lock<std::mutex> lk(m, std::defer_lock);

    // 在需要时获取锁
    lk.lock();

    // 处理一些数据，然后决定需要将锁传递给另一个函数
    handle_data(lk);

    // 锁的所有权在lk中，当lk被销毁时，锁会自动释放
}

int main() {
    std::thread t(process_data);
    t.join();
}

在上面的例子中，我们首先创建了一个未锁定的`std::unique_lock`对象`lk`，然后在`process_data`函数中手动获取了锁。之后，我们将锁的所有权传递给了`handle_data`函数，该函数可以使用同一把锁。当`lk`的作用域结束时，锁会被自动释放。

通过这些高级用法和性能优化技巧，std::unique_lock成为处理并发代码中复杂同步问题的一个有力工具。它为开发人员提供了足够的灵活性来控制锁的行为，而不会牺牲安全性和简洁性。

# 3. std::shared_lock的实践应用

在并发编程中，std::shared_lock是一种共享锁，它允许多个线程同时读取共享资源，但不允许写入。这种锁类型特别适合于读多写少的场景，因为它能够提高读操作的并发性。本章节深入探讨std::shared_lock的原理、