c++11 std::defer_lock, std::try_to_lock, std::adopt_lock

目录

1、std::adopt_lock

2、std::defer_lock

3、std::try_to_lock

4、compare


1、std::adopt_lock

Value used as possible argument to the constructor of unique_lock or lock_guard.

unique_lock objects constructed with adopt_lock do not lock the mutex object on construction, assuming instead that it is already locked by the current thread.

The value is a compile-time constant that carries no state, and is merely used to disambiguate between constructor signatures.

adopt_lock_t is an empty class.

2、std::defer_lock

Value used as possible argument to unique_lock's constructor.

unique_lock objects constructed with defer_lock do not lock the mutex object automatically on construction, initializing them as not owning a lock.

The value is a compile-time constant that carries no state, and is merely used to disambiguate between constructor signatures.

defer_lock_t is an empty class.

3、std::try_to_lock

Value used as possible argument to unique_lock's constructor.

unique_lock objects constructed with try_to_lock attempt to lock the mutex object by calling its try_lock member instead of its lock member.

The value is a compile-time constant that carries no state, and is merely used to disambiguate between constructor signatures.

4、compare

std::defer_lock 、 std::try_to_lock 和 std::adopt_lock 分别是空结构体标签类型 std::defer_lock_t 、 std::try_to_lock_t 和 std::adopt_lock_t 的实例。

它们用于为 std::lock_guard 、 std::unique_lock 及 std::shared_lock 指定锁定策

 
类型效果
defer_lock_t不获得互斥的所有权
try_to_lock_t尝试获得互斥的所有权而不阻塞
adopt_lock_t假设调用方线程已拥有互斥的所有权

 example

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

struct bank_account {
    explicit bank_account(int balance) : balance(balance) {}
    int balance;
    std::mutex m;
};

void transfer(bank_account &from, bank_account &to, int amount)
{
    // 锁定两个互斥而不死锁
    std::lock(from.m, to.m);
    // 保证二个已锁定互斥在作用域结尾解锁
    std::lock_guard<std::mutex> lock1(from.m, std::adopt_lock);
    std::lock_guard<std::mutex> lock2(to.m, std::adopt_lock);

// 等价方法:
//    std::unique_lock<std::mutex> lock1(from.m, std::defer_lock);
//    std::unique_lock<std::mutex> lock2(to.m, std::defer_lock);
//    std::lock(lock1, lock2);

    from.balance -= amount;
    to.balance += amount;
}

int main()
{
    bank_account my_account(100);
    bank_account your_account(50);

    std::thread t1(transfer, std::ref(my_account), std::ref(your_account), 10);
    std::thread t2(transfer, std::ref(your_account), std::ref(my_account), 5);

    t1.join();
    t2.join();

    std::cout<<"my balance"<<my_account.balance<<std::endl;
    std::cout<<"your balance"<<your_account.balance<<std::endl;
}

output:

std::defer_lock作为第二参数来传递,表示该互斥元在构造时保持未被锁定。这个锁就可以在这之后通过在std::unique_lock对象(不是互斥元)来上调用lock。 

  • 2
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值