Shouldn't this code be deadlocked?

I have a class that contains a mutex and an object, every time I need to access the contained object, a method is called to lock the mutex and return the object contained in the text to see the code:

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>;

      

        
        
        
      

    

The idea behind this code is to wrap an object and protect it from multiple access from multiple threads; the wrapped object has private visibility and the only way to access it is through the inner class Handler

, the expected usage is:

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;
}

      

        
        
        
      

    

So, if I'm not mistaken, the method call LockedResource::get

creates a value LockedResource::Handle

that blocks LockedResource::m_mutex

for its entire lifetime Handle

... but I must be wrong because the code below does not cause deadlocks:

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;
}

      

        
        
        
      

    

I expected the row to /*1*/

lock locked_vector.m_mutex

and then the row /*2*/

would try to lock the same already locked mutex causing a deadlock, but the output is as follows:

Resource locked
Resource locked
10
Resource unlocked
10
Resource unlocked

      

        
        
        
      

    

• Shouldn't the second ::get()
  
  get to a dead end?
• Am I accessing the wrapped resource through the same lock, or am I misunderstanding something?

Here's an example .