【C++11】【锁】C++11中的 std::lock_guard和std::unique_lock的差别

cpp@2021

已于 2025-08-06 11:33:06 修改

阅读量1k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： cxx 文章标签： cpp 指针锁 c++11

于 2021-11-08 12:52:19 首次发布

本文链接：https://blog.csdn.net/tang123246235/article/details/121205448

cxx 专栏收录该内容

7 篇文章

订阅专栏

本文探讨了C++11中std::lock_guard和std::unique_lock的区别。lock_guard提供简洁的自动锁定/解锁功能，适用于简单场景；而unique_lock具备更多功能，如手动锁定、解锁，能与条件变量配合使用，适用于更复杂的控制流程。两者都遵循RAII原则，但unique_lock允许在不持有mutex的情况下进行操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

@ 转载
看着这个老哥写的不错悄悄转过来

lock_guard

std::lock_guard使用起来比较简单，其在构造函数中对std::mutex变量进行锁定，在其析构函数中对std::mutex变量进行解锁，整个类没有对mutex进行解锁和加锁的对外接口，其源码如下：

template <class _Mutex>
class _LIBCPP_TYPE_VIS_ONLY lock_guard
{
public:
    typedef _Mutex mutex_type;
private:
    mutex_type& __m_;
public:
    _LIBCPP_INLINE_VISIBILITY
    explicit lock_guard(mutex_type& __m)
        : __m_(__m) {__m_.lock();}
    _LIBCPP_INLINE_VISIBILITY
    lock_guard(mutex_type& __m, adopt_lock_t)
        : __m_(__m) {}
    _LIBCPP_INLINE_VISIBILITY
    ~lock_guard() {__m_.unlock();}
private:
    lock_guard(lock_guard const&);// = delete;
    lock_guard& operator=(lock_guard const&);// = delete;
};

使用方法如下：

std::mutex g_mutex;
int g_var = 0;
void test_guard()
{
    std::lock_guard<std::mutex> guard(g_mutex);
    g_var ++;
}

unique_lock

unique_lock相比lock_guard，功能要多很多，其提供了对mutex的加锁（lock和try_lock）和解锁（unlock）操作，同时可以配合条件变量condition_variable使用：

template <class _Mutex>
class _LIBCPP_TYPE_VIS_ONLY unique_lock
{
public:
    typedef _Mutex mutex_type;
private:
    mutex_type* __m_;
    bool __owns_;
public:
    _LIBCPP_INLINE_VISIBILITY
    unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
    _LIBCPP_INLINE_VISIBILITY
    explicit unique_lock(mutex_type& __m)
        : __m_(&__m), __owns_(true) {__m_->lock();}
    _LIBCPP_INLINE_VISIBILITY
    unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
        : __m_(&__m), __owns_(false) {}
    _LIBCPP_INLINE_VISIBILITY
    unique_lock(mutex_type& __m, try_to_lock_t)
        : __m_(&__m), __owns_(__m.try_lock()) {}
    _LIBCPP_INLINE_VISIBILITY
    unique_lock(mutex_type& __m, adopt_lock_t)
        : __m_(&__m), __owns_(true) {}
    template <class _Clock, class _Duration>
    _LIBCPP_INLINE_VISIBILITY
        unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
            : __m_(&__m), __owns_(__m.try_lock_until(__t)) {}
    template <class _Rep, class _Period>
    _LIBCPP_INLINE_VISIBILITY
        unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
            : __m_(&__m), __owns_(__m.try_lock_for(__d)) {}
    _LIBCPP_INLINE_VISIBILITY
    ~unique_lock()
    {
        if (__owns_)
            __m_->unlock();
    }
private:
    unique_lock(unique_lock const&); // = delete;
    unique_lock& operator=(unique_lock const&); // = delete;
public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    unique_lock(unique_lock&& __u) _NOEXCEPT
        : __m_(__u.__m_), __owns_(__u.__owns_)
        {__u.__m_ = nullptr; __u.__owns_ = false;}
    _LIBCPP_INLINE_VISIBILITY
    unique_lock& operator=(unique_lock&& __u) _NOEXCEPT
        {
            if (__owns_)
                __m_->unlock();
            __m_ = __u.__m_;
            __owns_ = __u.__owns_;
            __u.__m_ = nullptr;
            __u.__owns_ = false;
            return *this;
        }
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    void lock();
    bool try_lock();
    template <class _Rep, class _Period>
        bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
    template <class _Clock, class _Duration>
        bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
    void unlock();
    _LIBCPP_INLINE_VISIBILITY
    void swap(unique_lock& __u) _NOEXCEPT
    {
        _VSTD::swap(__m_, __u.__m_);
        _VSTD::swap(__owns_, __u.__owns_);
    }
    _LIBCPP_INLINE_VISIBILITY
    mutex_type* release() _NOEXCEPT
    {
        mutex_type* __m = __m_;
        __m_ = nullptr;
        __owns_ = false;
        return __m;
    }
    _LIBCPP_INLINE_VISIBILITY
    bool owns_lock() const _NOEXCEPT {return __owns_;}
    _LIBCPP_INLINE_VISIBILITY
    _LIBCPP_EXPLICIT
        operator bool () const _NOEXCEPT {return __owns_;}
    _LIBCPP_INLINE_VISIBILITY
    mutex_type* mutex() const _NOEXCEPT {return __m_;}
};