std::unique_lock 移動語義

Question

請幫我檢查我對std::unique_lock移動語義的理解是否正確。
假設我有一個函數myFunc ，它需要在執行開始時獲取互斥鎖。
這個函數是從不同的函數調用的，其中一些函數例如myWrapper1在myFunc調用之前持有相同的互斥鎖。
有時我需要在myFunc的作用域退出時不釋放這個鎖。

typedef std::unique_lock<std::mutex> MyLock;
class Example2
{
    std::mutex m_data_mutex;

    MyLock&& myFunc(MyLock&& lk)
    {
        bool was_lock = lk.owns_lock();
        if( !was_lock ) lk.lock();

        std::cout << "myFunc" << std::endl;

        if( !was_lock ) lk.unlock();
        return std::move(lk);
    }

    void myWrapper1()
    {
        MyLock lk(m_data_mutex);
        std::cout << "1" << std::endl;
        lk = myFunc(std::move(lk));
        std::cout << "2" << std::endl;
    }

    void myWrapper2()
    {
        MyLock lk(m_data_mutex);
        std::cout << "1" << std::endl;
        lk.unlock();
        lk = myFunc(std::move(lk));
        std::cout << "2" << std::endl;
        lk.lock();
        std::cout << "3" << std::endl;
    }
};

所以問題是：

1. 對於myWrapper1 ，保證MyLock只會在myWrapper1作用域結束時myWrapper1 ，不是嗎？
2. 我對這個問題使用了正確的習語嗎？

Answer 1

有什么理由為什么你不能做這樣的事情嗎？ IMO，這比在所有者之間移動鎖要干凈得多。

std::mutex my_lock;

void myFunc_locked() {
    ...do something that requires my_lock to be locked...
}

void myFunc() {
    std::lock_guard<std::mutex> guard(my_lock);
    myFunc_locked();
}

void myWrapper1() {
    std::lock_guard<std::mutex> guard(my_lock);
    ...do something else that requires my_lock to be locked...
    myFunc_locked();
}

void myWrapper2() {
    ...
    myFunc();
}

---

或者，按照@Nevin 的建議進行操作。 也許更清潔：

std::mutex my_lock;

void myFunc(std::lock_guard<std::mutex>> const& guard) {
    ...do something that requires my_lock to be locked...
}

void myFunc() {
    std::lock_guard<std::mutex> guard(my_lock);
    myFunc(guard);
}

void myWrapper1() {
    std::lock_guard<std::mutex> guard(my_lock);
    ...do something else that requires my_lock to be locked...
    myFunc(guard);
}

void myWrapper2() {
    ...
    myFunc();
}