美文网首页
C++基础-mutex,time_mutex, lock_gua

C++基础-mutex,time_mutex, lock_gua

作者: kotlon | 来源:发表于2020-12-23 15:51 被阅读0次

    std:mutex

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

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

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

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

    mutex 的类信息如下:

    (构造函数) 构造互斥 (公开成员函数)
    (析构函数) 销毁互斥 (公开成员函数)
    operator=[被删除] 不可复制赋值 (公开成员函数)
    锁定
    lock 锁定互斥,若互斥不可用则阻塞 (公开成员函数)
    try_lock 尝试锁定互斥,若互斥不可用则返回 (公开成员函数)
    unlock 解锁互斥 (公开成员函数)
    原生句柄
    native_handle 返回底层实现定义的原生句柄 (公开成员函数)

    在实际的开发中,不会直接使用 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() 两个方法,可以指定等待锁的时间。

    类的相关信息如下:

    (构造函数) 构造 unique_lock ,可选地锁定提供的互斥 (公开成员函数)
    (析构函数) 若占有关联互斥,则解锁之 (公开成员函数)
    operator= 若占有则解锁互斥,并取得另一者的所有权 (公开成员函数)
    锁定
    lock 锁定关联互斥 (公开成员函数)
    try_lock 尝试锁定关联互斥,若互斥不可用则返回 (公开成员函数)
    try_lock_for 试图锁定关联的可定时锁定 (TimedLockable) 互斥,若互斥在给定时长中不可用则返回 (公开成员函数)
    try_lock_until 尝试锁定关联可定时锁定 (TimedLockable) 互斥,若抵达指定时间点互斥仍不可用则返回 (公开成员函数)
    unlock 解锁关联互斥 (公开成员函数)
    修改器
    swap 与另一 std::unique_lock 交换状态 (公开成员函数)
    release 将关联互斥解关联而不解锁它 (公开成员函数)
    观察器
    mutex 返回指向关联互斥的指针 (公开成员函数)
    owns_lock 测试锁是否占有其关联互斥 (公开成员函数)
    operator bool 测试锁是否占有其关联互斥 (公开成员函数)

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

    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

    相关文章

      网友评论

          本文标题:C++基础-mutex,time_mutex, lock_gua

          本文链接:https://www.haomeiwen.com/subject/ooxunktx.html