这段代码不应该导致死锁吗？

Question

我有一个包含互斥锁和一个对象的类，每次我需要访问包含的对象时，都会调用一个方法来锁定互斥锁并返回包含的对象，让我们看看代码：

template <typename MUTEX, typename RESOURCE>
class LockedResource
{
    using mutex_t    = MUTEX;
    using resource_t = RESOURCE;

    mutex_t    m_mutex;
    resource_t m_resource;

public:
        template <typename ... ARGS>
        LockedResource(ARGS &&... args) :
                m_resource(std::forward<ARGS>(args) ...)
        {}

    class Handler
    {
        std::unique_lock<mutex_t> m_lock;      // unique lock
        resource_t                &m_resource; // Ref to resource

        friend class LockedResource;

        Handler(mutex_t &a_mutex, resource_t &a_resource) :
            m_lock(a_mutex),       // mutex automatically locked
            m_resource(a_resource)
        { std::cout << "Resource locked\n"; }

    public:
        Handler(Handler &&a_handler) :
            m_lock(std::move(a_handler.m_lock)),
            m_resource(a_handler.m_resource)
        { std::cout << "Moved\n"; }

        ~Handler() // mutex automatically unlocked
        { std::cout << "Resource unlocked\n"; }

        RESOURCE *operator->()
        { return &m_resource; }
    };

    Handler get()
    { return {m_mutex, m_resource}; }
};

template <typename T> using Resource = LockedResource<std::mutex, T>;

这段代码背后的想法是包装一个对象并保护它免受多个线程的多次访问；包装的对象具有私有可见性，访问它的唯一方法是通过内部类Handler，预期用法如下：

LockedResource<std::mutex, Foo> locked_foo;
void f()
{
    auto handler = locked_foo.get(); // this will lock the locked_foo.m_mutex;
    handler->some_foo_method();
    // going out of the scope will call the handler dtor and
    // unlock the locked_foo.m_mutex;
}

因此，如果我没记错的话，调用该LockedResource::get方法会创建一个LockedResource::Handle值，该值会LockedResource::m_mutex在Handle...的整个生命周期内锁定...但我一定是弄错了，因为下面的代码不会导致死锁：

LockedResource<std::mutex, std::vector<int>> locked_vector{10, 10};

int main()
{
/*1*/  auto vec = locked_vector.get(); // vec = Resource<vector>::Handler
/*2*/  std::cout << locked_vector.get()->size() << '\n';
/*3*/  std::cout << vec->size() << '\n';
    return 0;
}

我期待该行/*1*/锁定locked_vector.m_mutex然后该行/*2*/尝试锁定导致死锁的相同已锁定互斥锁，但输出如下：

Resource locked
Resource locked
10
Resource unlocked
10
Resource unlocked

• 第二个不应该::get()导致僵局吗？
• 我是通过同一个锁访问包装的资源还是我误解了什么？

这是example code.

Answer 1

好吧，快速测试显示以下内容：

1. GCC - 显示问题中显示的输出
2. Clang - 进程在我使用的在线编译器上被杀死。于是陷入僵局。
3. MSVC2013 - “设备或资源繁忙：设备或资源繁忙” - 被抛出。它检测到试图在同一线程上锁定已锁定的互斥锁。

什么标准必须说呢？

30.4.1.2.1/4 [ 注意：如果拥有互斥对象的线程对该对象调用 lock() ，则程序可能会死锁。如果实现可以检测到死锁，则可能会观察到resource_deadlock_would_occur 错误条件。— 尾注 ]

但是根据 30.4.1.2/13 它应该抛出以下之一：

— resource_deadlock_would_occur — if the implementation detects that a deadlock would occur. 
— device_or_resource_busy — if the mutex is already locked and blocking is not possible.

所以答案是肯定的，你观察到的是一种不正确的行为。它应该阻塞或抛出但不继续，因为什么都没有发生。

观察到的行为是可能的，因为您在代码中有 UB。根据 17.6.4.11，违反Requires条款是 UB，在 30.4.1.2/7 中，我们有以下要求：

要求：若 m 为 std::mutex、std::timed_mutex 或 std::shared_timed_mutex 类型，则调用线程不拥有互斥锁。

感谢@TC 指出 UB。