unique_lock 忙等待

unique_lock 是一个 C++ 的线程库中的互斥锁（mutex）的封装类，它提供了一种更灵活的加锁和解锁机制。它可以用于实现忙等待（busy waiting）的功能，即线程在尝试获取锁失败后会一直循环等待直到成功获取锁为止。

在使用 unique_lock 进行忙等待时，可以通过不同的构造函数来指定等待策略。其中比较常见的有以下几种：

1. 默认构造函数：使用默认构造函数创建的 unique_lock 对象不会进行忙等待，而是会阻塞当前线程，直到锁可用。
2. try_to_lock：通过 try_to_lock 构造函数创建的 unique_lock 对象会尝试获取锁，如果获取成功则继续执行，如果获取失败则立即返回而不进行等待。
3. defer_lock：通过 defer_lock 构造函数创建的 unique_lock 对象不会自动加锁，需要手动调用 lock() 函数才能获取锁。

需要注意的是，在使用 unique_lock 进行忙等待时，应该避免无限循环，以免造成 CPU 资源的浪费。可以通过在循环中添加一些条件判断来控制循环次数或者添加适当的延时操作。此外，还可以考虑使用条件变量等更高级的线程同步机制来替代忙等待，以提高程序的性能和效率。

相关问题

unique_lock 和 shared_lock

unique_lock 和 shared_lock 是 C++ 中的两种锁类型，用于实现多线程的同步操作。

unique_lock 是一种独占锁，它允许一个线程对其加锁，其他线程在此期间无法获取相同的锁。unique_lock 提供了更多的灵活性，可以在构造时指定锁的类型（独占或共享），以及在任意时间点上锁和解锁。unique_lock 还支持轮询、超时和延迟加锁等功能，并提供了更高级别的异常安全保证。

shared_lock 是一种共享锁，它允许多个线程同时获取相同的锁，用于实现共享访问。与 unique_lock 不同，shared_lock 对于多个线程来说是共享的，当所有线程释放锁后，其他线程才能再次获取锁。shared_lock 适用于读取多写入少的场景，可以提高并发性能。

这两种锁类型都是基于互斥量(mutex)实现的，可以用于保护共享资源的访问。选择使用 unique_lock 还是 shared_lock 取决于具体的应用场景和需求。

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 所不具备的功能。