【C++】独占互斥锁（unique_lock）

C++ unique_lock 学习笔记

1. 了解 C++ 中的独占互斥锁（unique_lock）

• 作用：unique_lock 是一个RAII（资源获取即初始化）类，用于管理互斥锁的加锁和解锁操作，提供更灵活的锁定和解锁机制。
• 优势：相比于 lock_guard，unique_lock 提供了更多的灵活性，可以手动控制锁的加锁和解锁时机，支持延迟加锁和条件变量等高级特性。
• 发展历程：C++11 引入了 unique_lock 类，作为对传统的手动管理互斥锁的一种封装。

示例代码：

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

std::mutex mtx;

void thread_function() {
    std::unique_lock<std::mutex> lock(mtx); // 创建 unique_lock 对象并锁定互斥锁
    std::cout << "Thread is executing..." << std::endl;
} // unique_lock 对象超出作用域，自动释放互斥锁

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

    return 0;
}

2. 学习 C++ 中的独占互斥锁的多种应用场景

• 条件变量：unique_lock 可以与条件变量配合使用，实现线程的等待和唤醒机制。
• 超时等待：unique_lock 支持超时等待，可以指定在一定时间内等待互斥锁的释放。
• 递归锁：unique_lock 支持递归锁，同一个线程可以多次加锁同一个互斥锁。

示例代码：

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

std::mutex mtx;
std::condition_variable cv;
bool data_ready = false;

void producer_thread() {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟生产数据的耗时操作
    {
        std::unique_lock<std::mutex> lock(mtx);
        data_ready = true;
    }
    cv.notify_one(); // 通知消费者数据已准备好
}

void consumer_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return data_ready; }); // 等待数据准备就绪
    std::cout << "Data is ready." << std::endl;
}

int main() {
    std::thread producer(producer_thread);
    std::thread consumer(consumer_thread);

    producer.join();
    consumer.join();

    return 0;
}

3. 掌握 C++ 中的独占互斥锁的使用技巧

• 手动控制：unique_lock 允许手动控制锁的加锁和解锁时机，提供了 lock() 和 unlock() 方法，更加灵活。
• 条件变量：unique_lock 可以与条件变量一起使用，实现线程的等待和唤醒，更好地实现线程间的同步。
• 超时等待：unique_lock 支持超时等待功能，可以指定等待时间，避免长时间阻塞线程。

示例代码：

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

std::mutex mtx;
std::condition_variable cv;
bool data_ready = false;

void producer_thread() {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟生产数据的耗时操作
    {
        std::unique_lock<std::mutex> lock(mtx);
        data_ready = true;
    }
    cv.notify_one(); // 通知消费者数据已准备好
}

void consumer_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    if(cv.wait_for(lock, std::chrono::seconds(2), [] { return data_ready; })) { // 超时等待
        std::cout << "Data is ready." << std::endl;
    } else {
        std::cout << "Timeout, data is not ready." << std::endl;
    }
}

int main() {
    std::thread producer(producer_thread);
    std::thread consumer(consumer_thread);

    producer.join();
    consumer.join();

    return 0;
}

4. 实战案例分析

• 生产者-消费者模型：使用 unique_lock 和条件变量实现生产者-消费者模型，确保生产者在数据准备好后通知消费者。

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

std::mutex mtx;
std::condition_variable cv;
int data = 0;
bool data_ready = false;

void producer_thread() {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟生产数据的耗时操作
    {
        std::lock_guard<std::mutex> lock(mtx);
        data = 42; // 生产数据
        data_ready = true;
    }
    cv.notify_one(); // 通知消费者数据已准备好
}

void consumer_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return data_ready; }); // 等待数据准备就绪
    std::cout << "Consumer got data: " << data << std::endl; // 消费数据
}

int main() {
    std::thread producer(producer_thread);
    std::thread consumer(consumer_thread);

    producer.join();
    consumer.join();

    return 0;
}

• 超时等待：在一定时间内等待数据准备就绪，超时则执行相应逻辑，确保线程不会长时间阻塞。

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

std::mutex mtx;
std::condition_variable cv;
int data = 0;
bool data_ready = false;

void producer_thread() {
    std::this_thread::sleep_for(std::chrono::seconds(3)); // 模拟生产数据的耗时操作
    {
        std::lock_guard<std::mutex> lock(mtx);
        data = 42; // 生产数据
        data_ready = true;
    }
    cv.notify_one(); // 通知消费者数据已准备好
}

void consumer_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    if (cv.wait_for(lock, std::chrono::seconds(2), [] { return data_ready; })) { // 等待数据准备就绪，超时时间为2秒
        std::cout << "Consumer got data: " << data << std::endl; // 消费数据
    } else {
        std::cout << "Timeout, no data available." << std::endl; // 超时逻辑
    }
}

int main() {
    std::thread producer(producer_thread);
    std::thread consumer(consumer_thread);

    producer.join();
    consumer.join();

    return 0;
}

通过学习和掌握 C++ 中的 unique_lock，可以更灵活地管理互斥锁，实现更复杂的线程同步机制，提高代码的可读性和可维护性。