std:mutex

在 C++ 中，mutex 类能用于保护共享数据从多个线程同时访问的同步原语。

mutex 提供排他性非递归所有权语义：

• 调用方线程从它成功调用 lock 或者 try_lock 开始，到它调用 unlock 为止，占用该 mutex
• 调用线程占用 mutex，所有其它线程试图要求 mutex 的所有权，如果请求线程调用 lock(),则将阻塞;如果请求线程调用 try_lock() 则返回 false。

如果 mutex 在被线程占用的时候被销毁，或者占用 mutex 的时候线程终止，则行为未定义。

mutex 的类信息如下：

在实际的开发中，不会直接使用 mutex ，而是使用 std:unique_lock,std::lock_guard,std::scoped_lock 等方式进行加锁。

std::recursive_mutex

和 std::mutex 一样，但是 std::recursive_mutex 允许同一个线程对互斥量多次上锁，也就是递归上锁，来获得互斥对象的多层所有权，同时释放互斥量也要调用锁深度层次相同的 unlock() 方法。

std::time_mutex

std::time_mutex 比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until()。

try_lock_for() 表示函数接受一个时间范围，也就是在这个时间段范围内没有获取锁，则该线程被阻塞。

try_lock_until 函数则接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

示例代码如下：

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

std::timed_mutex t_mutex;
void fire_work() {
    //try_lock_for 会等待一段时间，
    while (!t_mutex.try_lock_for(chrono::milliseconds(200))) {
        std::cout << "-";
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    cout << "*\n";
    t_mutex.unlock();
}

int main() {
    std::thread threads[10];
    // spawn 10 threads:
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(fire_work);

    for (auto &th : threads) th.join();
    return 0;
}

最后控制台输入如下：

------------------------------------*
----------------------------------------*
-----------------------------------*
------------------------------*
-------------------------*
--------------------*
---------------*
----------*
-----*
*

示例代码中，启动了十个线程,然后每个线程都会对互斥信号量 t_mutex，请求 lock。第一个线程，拿到了 lock，然后直接打印了 *,第二个线程，try_lock 会等待 200 。

std::lock_guard

源码位于头文件 <mutex> 中，template<class Mutex> class lock_grard

该类是互斥体的包装器，为在作用域块期间内占用互斥提供便利的 RAII 风格机制，也就是资源获取即初始化机制。

从逻辑上来说，创建 lock_guard() 对象时，它试图接受给定互斥的所有权。控制离开创建 lock_guard 对象的作用域时，销毁 lock_guard 并且是否互斥。

简单例子如下：

#include <mutex>
#include <thread>
//声明空间
using namespace std;

int g_i = 0;
mutex g_i_mutex;//定义一个互斥信息

void safe_increment() {
    //创建 lock_guard 对象，并且使用g_i_mutex 作为构造函数参数
    //在整个方法作用域里面，这锁都是生效的
    lock_guard<std::mutex> lock(g_i_mutex);
    //操作需要互斥的变量之前，先创建 lock_guard<std::mutex>  对象
    g_i++;
}


int main() {
    thread t1(safe_increment);
    thread t2(safe_increment);
    t1.join();
    t2.join();
}

lock_grard 的原理很简单，在对象的构造函数中，调用 mutex.lock()，然后在析构函数中，调用 unlock(),源码如下：

explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
    : __m_(__m) {__m_.lock();}

lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
    : __m_(__m) {}
~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}

std::unique_lock

源码位于头文件 <mutex> 中，template<class Mutex> class unique_lock

和 std::lock_guard() 类似，但是提供了更好的上锁机制和解锁控制。包含了 try_lock_for() 和 try_lock_unitl() 两个方法，可以指定等待锁的时间。

类的相关信息如下：

示例代码如下，以一个银行转账的业务为例子：

void transfer(bank_account &from, bank_account &to, int amount) {
    //defer_lock 表示延迟加锁,实际上未获取锁
    unique_lock<mutex> lock1(from.mMutex, defer_lock);
    unique_lock<mutex> lock2(to.mMutex, defer_lock);
    //获取锁
    lock(lock1, lock2);
    from.iMoney -= amount;
    to.iMoney += amount;
}

void test_transfer() {
    bank_account Account1("User1", 100);
    bank_account Account2("User2", 50);
    thread t1([&]() { transfer(Account1, Account2, 10); });//lambda表达式
    thread t2([&]() { transfer(Account2, Account1, 5); });
    t1.join();
    t2.join();
}

参考

RAII