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,可以更灵活地管理互斥锁,实现更复杂的线程同步机制,提高代码的可读性和可维护性。