unique_lock头文件

unique_lock是C++11中引入的一种锁类型，声明在<mutex>头文件中。它与lock_guard一样，都可以实现自动加锁和解锁的功能，但是unique_lock相对更灵活，可以在构造函数中指定锁的类型（独占锁或共享锁），并且可以在运行时动态地加锁和解锁。此外，unique_lock还支持锁的所有权的转移，即可以将一个unique_lock对象的所有权转移给另一个unique_lock对象，这在某些情况下可以提高代码的效率。

相关问题

unique_lock con

unique_lock是C++标准库中的一个互斥锁封装类，它提供了更灵活的互斥锁操作方式。通过unique_lock，我们可以实现更加安全和高效的多线程编程。

unique_lock的主要特点如下：
1. unique_lock提供了与互斥锁相关的基本操作，如上锁、解锁等。
2. unique_lock支持自动上锁和解锁，可以在构造函数中指定是否自动上锁。
3. unique_lock可以随时释放锁，也可以重新上锁，这使得代码更加灵活。
4. unique_lock还支持延迟上锁和递归上锁，可以根据需要选择不同的上锁方式。

使用unique_lock时，需要包含头文件<mutex>。下面是unique_lock的基本用法示例：

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

std::mutex mtx;

void printMessage(const std::string& message) {
    std::unique_lock<std::mutex> lock(mtx); // 上锁
    std::cout << message << std::endl;
    // lock会在作用域结束时自动解锁
}

int main() {
    std::thread t1(printMessage, "Hello");
    std::thread t2(printMessage, "World");
    
    t1.join();
    t2.join();
    
    return 0;
}

在上述示例中，我们使用unique_lock对共享资源进行了保护。通过上锁和解锁操作，确保了printMessage函数的输出不会被多个线程同时访问。

unique_lock源码

unique_lock 是 C++11 中新增的一种互斥量封装类，用于更方便地管理互斥量的加锁和解锁。它的源码实现在 <mutex> 头文件中。

unique_lock 是一个模板类，定义如下：

template<class Mutex>
class unique_lock {
public:
    // 构造函数
    explicit unique_lock(Mutex& m);
    unique_lock(Mutex& m, defer_lock_t);
    unique_lock(Mutex& m, try_to_lock_t);
    unique_lock(Mutex& m, adopt_lock_t);
    template<class Clock, class Duration>
    unique_lock(Mutex& m, const chrono::time_point<Clock, Duration>& abs_time);
    template<class Rep, class Period>
    unique_lock(Mutex& m, const chrono::duration<Rep, Period>& rel_time);

    // 析构函数
    ~unique_lock();

    // 成员函数
    void lock();
    bool try_lock();
    void unlock();
    void swap(unique_lock& other) noexcept;
    bool owns_lock() const noexcept;
    explicit operator bool() const noexcept;

    // 禁止拷贝和赋值
    unique_lock(const unique_lock&) = delete;
    unique_lock& operator=(const unique_lock&) = delete;

    // 友元函数
    template<class Mutex2>
    friend class unique_lock;
};

unique_lock 有多个构造函数，用于不同的场景：默认构造函数会创建一个未关联互斥量的 unique_lock 对象；explicit unique_lock(Mutex& m) 构造函数会创建一个关联了互斥量 m 的 unique_lock 对象，并立即对互斥量进行加锁；unique_lock(Mutex& m, try_to_lock_t) 构造函数会尝试对互斥量 m 进行加锁，如果加锁失败则不会阻塞线程，而是立即返回 false；unique_lock(Mutex& m, adopt_lock_t) 构造函数会创建一个 unique_lock 对象，但是假设调用者已经对互斥量 m 进行加锁，因此 unique_lock 对象不会再对互斥量进行加锁，而是认为互斥量已经被加锁了；unique_lock(Mutex& m, const chrono::time_point<Clock, Duration>& abs_time) 和 unique_lock(Mutex& m, const chrono::duration<Rep, Period>& rel_time) 构造函数会尝试在指定的时间内对互斥量进行加锁。

unique_lock 的成员函数包括：

- lock()：对关联的互斥量进行加锁。
- try_lock()：尝试对关联的互斥量进行加锁，如果加锁成功则返回 true，否则返回 false。
- unlock()：对关联的互斥量进行解锁。
- swap(unique_lock& other)：交换两个 unique_lock 对象的状态。
- owns_lock()：返回当前 unique_lock 对象是否拥有互斥量的所有权。
- operator bool()：返回当前 unique_lock 对象是否拥有互斥量的所有权。

此外，unique_lock 还有一个特殊的成员函数，用于将 unique_lock 对象转换为 lock_guard 对象：

template<class Mutex>
std::lock_guard<Mutex> unique_lock<Mutex>::release() noexcept;

该函数会将当前 unique_lock 对象所拥有的互斥量的所有权转移到一个新的 lock_guard 对象中，并将当前 unique_lock 对象重置为未关联任何互斥量的状态。

unique_lock 的实现方式与 lock_guard 类似，都是通过 RAII 技术来实现对互斥量的加锁和解锁。不同的是，unique_lock 提供了更加灵活的构造函数和成员函数，可以在更多的场景下使用。此外，unique_lock 还支持线程间传递所有权，这是 lock_guard 所不具备的功能。