unique_lock和lock_guard源码

unique_lock和lock_guard都是C++11中的互斥锁封装类，用于简化互斥锁的使用。它们的实现都是基于模板类，可以用于任何类型的互斥锁。

unique_lock源码：

unique_lock的实现是比较复杂的，因为它支持多种锁的模式（例如独占模式、共享模式、延迟加锁等），同时还支持多种锁的操作（例如加锁、解锁、尝试加锁等）。下面是unique_lock的主要源码：

template<class Mutex>
class unique_lock
{
public:
    // 构造函数
    explicit unique_lock(Mutex& m);
    unique_lock(Mutex& m, std::defer_lock_t);
    unique_lock(Mutex& m, std::try_to_lock_t);
    unique_lock(Mutex& m, std::adopt_lock_t);
    template<class Clock, class Duration>
    unique_lock(Mutex& m, const std::chrono::time_point<Clock,Duration>& abs_time);
    template<class Rep, class Period>
    unique_lock(Mutex& m, const std::chrono::duration<Rep,Period>& rel_time);
    
    // 析构函数
    ~unique_lock();
    
    // 加锁、解锁、尝试加锁等操作
    void lock();
    bool try_lock();
    void unlock();
    
    // 转移锁的所有权
    Mutex* release();
    void swap(unique_lock& u);
    
    // 获取锁的状态
    bool owns_lock() const noexcept;
    explicit operator bool () const noexcept;
};

unique_lock的实现主要依赖于Mutex类的成员函数，例如lock、try_lock、unlock等。在创建unique_lock对象时，可以指定不同的锁的模式和操作。例如，可以通过std::defer_lock_t指定延迟加锁，在构造函数中不进行加锁操作；通过std::try_to_lock_t指定尝试加锁，在构造函数中尝试加锁，但不阻塞；通过std::adopt_lock_t指定已经持有锁的线程，将unique_lock对象与该锁关联。

lock_guard源码：

lock_guard的实现相对简单，因为它只支持一种锁模式（独占模式），同时也只支持加锁和解锁操作。下面是lock_guard的主要源码：

template<class Mutex>
class lock_guard
{
public:
    // 构造函数
    explicit lock_guard(Mutex& m);
    
    // 析构函数
    ~lock_guard();
    
    // 加锁、解锁操作
    lock_guard(const lock_guard&) = delete;
    lock_guard& operator=(const lock_guard&) = delete;
};

lock_guard的实现主要依赖于Mutex类的成员函数，例如lock和unlock。在创建lock_guard对象时，会自动进行加锁操作，在销毁对象时会自动进行解锁操作，因此不需要手动调用lock和unlock函数。如果复制或赋值lock_guard对象，会发生编译错误，因为lock_guard对象是非复制和非移动的。