std::unique_lock

在多线程编程中，std::unique_lock 是一个比 std::lock_guard 更灵活的互斥锁管理工具。它提供了对互斥锁的高级控制，包括延迟锁定、定时锁定和尝试锁定等。

解释 std::unique_lock<std::mutex>

1. std::unique_lock<std::mutex>：

   • std::unique_lock 是一个模板类，用于管理互斥锁（如 std::mutex）的所有权。与 std::lock_guard 不同，std::unique_lock 提供了延迟锁定、定时锁定和尝试锁定等高级功能。

2. std::defer_lock：

   • std::defer_lock 是一个用于初始化 std::unique_lock 的特殊标记。使用 std::defer_lock 初始化 std::unique_lock 时，互斥锁不会被立即锁定。这允许程序员在需要时手动锁定互斥锁。

示例代码

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

std::mutex mtx;
std::vector<int> data;

void worker(int id) {
    // 延迟锁定互斥锁
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);

    // 模拟工作负载
    int work = 5;
    for (int i = 0; i < work; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));

        // 锁定互斥锁
        lock.lock();

        // 安全地访问共享数据
        data.push_back(id);

        // 解锁互斥锁
        lock.unlock();
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(worker, i);
    }

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

    std::cout << "Data size: " << data.size() << std::endl;
    return 0;
}

解释示例代码

1. 初始化 std::unique_lock：

   std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
   

   • 这里使用 std::defer_lock 初始化 std::unique_lock，互斥锁 mtx 在初始化时不会被锁定。

2. 模拟工作负载：

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

   • 模拟一些工作负载，例如等待或计算。

3. 锁定互斥锁：

   lock.lock();
   

   • 在需要访问共享资源（如 data 向量）之前，显式地锁定互斥锁。

4. 安全地访问共享数据：

   data.push_back(id);
   

   • 在互斥锁的保护下，安全地访问和修改共享数据。

5. 解锁互斥锁：

   lock.unlock();
   

   • 完成对共享资源的操作后，解锁互斥锁，以便其他线程可以访问。

为什么使用 std::unique_lock 而不是 std::lock_guard？

1. 延迟锁定：

   • std::unique_lock 允许延迟锁定互斥锁，这在某些情况下非常有用，例如在需要条件锁定或在异常处理中解锁时。

2. 灵活性：

   • std::unique_lock 提供了更多的灵活性，包括尝试锁定（try_lock）、定时锁定（try_lock_for 和 try_lock_until）等。

3. 可重入：

   • std::unique_lock 可以在同一线程中多次锁定和解锁，而 std::lock_guard 只能锁定一次。

4. 解锁和重新锁定：

   • std::unique_lock 允许在锁定后解锁，然后在需要时重新锁定，这在某些复杂的同步操作中非常有用。

通过使用 std::unique_lock 和 std::defer_lock，可以更灵活地控制互斥锁的锁定和解锁，从而更好地管理线程间的同步和共享资源的访问。