C++ 并发编程,std::unique_lock与std::lock_guard区别示例

背景

平时看代码时,也会使用到std::lock_guard,但是std::unique_lock用的比较少。在看并发编程,这里总结一下。方便后续使用。

std::unique_lock也可以提供自动加锁、解锁功能,比std::lock_guard更加灵活。

std::lock_guard

std::lock_guard是RAII模板类的简单实现,功能简单。

1.std::lock_guard 在构造函数中进行加锁,析构函数中进行解锁。
2.锁在多线程编程中,使用较多,因此c++11提供了lock_guard模板类;在实际编程中,我们也可以根据自己的场景编写resource_guard RAII类,避免忘掉释放资源。

下面是一个使用std::lock_guard的代码例子,1+2+ .. + 100的多线程实现,每个num只能由一个线程处理。:

#include <thread>
#include <mutex>
#include <vector>
#include <iostream>
#include <algorithm>

std::mutex my_lock;

void add(int &num, int &sum){
    while(true){
        std::lock_guard<std::mutex> lock(my_lock);  
        if (num < 100){ //运行条件
            num += 1;
            sum += num;
        }   
        else {  //退出条件
            break;
        }   
    }   
}

int main(){
    int sum = 0;
    int num = 0;
    std::vector<std::thread> ver;   //保存线程的vector
    for(int i = 0; i < 20; ++i){
        std::thread t = std::thread(add, std::ref(num), std::ref(sum));
        ver.emplace_back(std::move(t)); //保存线程
    }   

    std::for_each(ver.begin(), ver.end(), std::mem_fn(&std::thread::join)); //join
    std::cout << sum << std::endl;
}

std::unique_lock

类 unique_lock 是通用互斥包装器,允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与条件变量一同使用
unique_lock比lock_guard使用更加灵活,功能更加强大。
使用unique_lock需要付出更多的时间、性能成本。

下面是try_lock的使用例子。

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::unique_lock
#include <vector>

std::mutex mtx;           // mutex for critical section
std::once_flag flag;

void print_block (int n, char c) {
    //unique_lock有多组构造函数, 这里std::defer_lock不设置锁状态
    std::unique_lock<std::mutex> my_lock (mtx, std::defer_lock);
    //尝试加锁, 如果加锁成功则执行
    //(适合定时执行一个job的场景, 一个线程执行就可以, 可以用更新时间戳辅助)
    if(my_lock.try_lock()){
        for (int i=0; i<n; ++i)
            std::cout << c;
        std::cout << '\n';
    }
}

void run_one(int &n){
    std::call_once(flag, [&n]{n=n+1;}); //只执行一次, 适合延迟加载; 多线程static变量情况
}

int main () {
    std::vector<std::thread> ver;
    int num = 0;
    for (auto i = 0; i < 10; ++i){
        ver.emplace_back(print_block,50,'*');
        ver.emplace_back(run_one, std::ref(num));
    }

    for (auto &t : ver){
        t.join();
    }
    std::cout << num << std::endl;
    return 0;
}

参考

参考资源链接:[C++多线程实现消息队列示例代码详解](https://wenku.youkuaiyun.com/doc/645346ccea0840391e779119?utm_source=wenku_answer2doc_content) std::lock_guardstd::unique_lockC++11中用于管理互斥锁的两种RAII(Resource Acquisition Is Initialization)风格的类。它们提供了一种安全、异常安全的方式来管理锁的生命周期,确保锁的获取和释放能够自动发生,即使在发生异常时也是如此。在多线程消息队列的实现中,这两种锁提供了不同层次的控制和灵活性。 std::lock_guard是较为简单的RAII互斥锁封装。它在构造函数中自动上锁,并在析构函数中自动解锁。由于它不允许显式地解锁或转移所有权,因此std::lock_guard特别适合那些不需要锁的所有权和灵活操作的场景。它的实现非常轻量,因为它不保存任何锁相关的状态。在消息队列中,std::lock_guard可以用于简单的同步访问,确保在处理消息的生命周期内始终保持锁。 std::unique_lock提供了std::lock_guard的所有功能,并且增加了额外的灵活性。它支持延迟锁、尝试锁定、锁的转移和条件变量的通知等操作。std::unique_lock可以解除互斥锁的关联,然后重新其他互斥锁关联,这使得它适合更复杂的同步场景。在使用条件变量等待时,通常推荐使用std::unique_lock,因为它提供了必要的灵活性来满足条件变量操作的要求。 在实现消息队列时,std::unique_lock允许线程在等待通知的同时解锁互斥锁,从而提高消息队列的并发性。当条件变量的通知发生时,std::unique_lock可以被用来重新锁定互斥锁,并处理消息。这在std::lock_guard中是不可能的,因为std::lock_guard没有提供这样的操作。 综上所述,虽然std::lock_guard提供了简单且高效的锁定机制,适用于不需要锁所有权转移和额外操作的简单场景,std::unique_lock在需要更多控制和灵活性的多线程消息队列实现中则更为适用。了解它们的用途和区别对于编写有效的多线程程序至关重要。 如果你想进一步探索这些概念,并看到如何在实际代码中运用它们,可以参考《C++多线程实现消息队列示例代码详解》。这份资源将为你提供详细的示例和解释,帮助你更好地理解std::lock_guardstd::unique_lock在多线程消息队列中的应用。 参考资源链接:[C++多线程实现消息队列示例代码详解](https://wenku.youkuaiyun.com/doc/645346ccea0840391e779119?utm_source=wenku_answer2doc_content)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值