C++多线程编程（4）：共享锁与互斥锁

🔆 文章首发于我的个人博客：欢迎大佬们来逛逛

共享锁

1. 使用 mutex 进行加锁与开锁

mutex.lock()
...
mutex.unlock()

1. 使用 lock_guard 实现lock与unlock

lock_guard实际上就是对mutex的封装

class _NODISCARD_LOCK lock_guard { // class with destructor that unlocks a mutex
public:
    using mutex_type = _Mutex;

    explicit lock_guard(_Mutex& _Mtx) : _MyMutex(_Mtx) { // construct and lock
        _MyMutex.lock();
    }

    lock_guard(_Mutex& _Mtx, adopt_lock_t) : _MyMutex(_Mtx) {} // construct but don't lock

    ~lock_guard() noexcept {
        _MyMutex.unlock();
    }

    lock_guard(const lock_guard&)            = delete;
    lock_guard& operator=(const lock_guard&) = delete;

private:
    _Mutex& _MyMutex;
};

互斥锁

1. 使用 unique_lock 实现互斥锁

std::unique_lock<std::mutex> uLk(m_mutex);

2. 使用 unique_lock 的 adopt_lock

adopt_lock假设调用一方线程已拥有互斥的所有权

m_mutex.lock(); //首先要加锁
std::unique_lock<std::mutex> uLk(m_mutex, std::adopt_lock);

3. 使用 unique_lock 的 defer_lock

defer_lock不获得互斥的所有权（或在稍后获得）

std::unique_lock<std::mutex> uLk(m_mutex, std::defer_lock);
uLk.lock();
uLk.unlock();

4. 使用 unique_lock 的 try_to_lock

try_to_lock尝试获得互斥的所有权而不阻塞

std::unique_lock<std::mutex> uLk(m_mutex, std::try_to_lock);
if (uLk.owns_lock()) {
		...
}