Question

在回答this question之后，有一件事再次困扰我并让我疯狂：

如果一个thread_1当前正在尝试锁定互斥锁而另一个thread_2解锁了这个互斥锁，那么还是有一个保证，thread_1会获得互斥锁，然后thread_2才会再次锁定它。

为了确保目前正在尝试锁定，我认为std::condition_variable::wait与std::mutex::lock具有相同的部分，而不仅仅是while(try_lock())

我认为答案是否定的，因为调度std::mutex的实现方式各不相同。但我不确定并试图不是一个声誉妓女，但是，

This question没有目前正在尝试锁定
This question澄清了解锁/锁定与部分同步但未解决此一般问题

我只是想确定一下。也许我有偏执狂。

示范码：

#include <thread>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <cassert>

std::mutex lock; 
std::condition_variable ensure_in_lock;
std::atomic<int> invariant = 1;

void thread_1(){
    while (true){
        std::unique_lock<std::mutex> ul(lock);
        invariant++;
        ensure_in_lock.wait(ul);
        invariant++;
    }
}

void thread_2(){
    while (true){
        lock.lock();
        assert(invariant > 0); //<- This should be, in theory, able to break, shouldn't it?!
        ensure_in_lock.notify_all();
        lock.unlock();
        invariant--;
    }
}

int main(void)
{
    std::thread t1(thread_1);
    /*
    //make sure t1 really had started like with thread_once or pratically with this
    std::this_thread::sleep_for(std::chrono::seconds(1));
    */
    std::thread t2(thread_2);

    while (true);
    return 0;
}

Answer 1

如果thread_1当前正在尝试锁定互斥锁而另一个thread_2解锁此互斥锁，是否有保证，thread_1将获得互斥锁，然后thread_2才会尝试再锁定它。

不仅没有保证，而且这样的保证会要求最大限度地实施，最大化上下文切换而不是最小化它们。如果一个线程可以继续，你想让它继续下去并耗尽它的时间片。你不想在两个线程之间切换，让每个线程都能略微增加进度。

锁定的一个好处是它们倾向于计划竞争线程，允许线程运行更长时间而不会因争用而导致性能损失。这种交错要求会否定这种好处。

含义std :: mutex unlock与lock同步以重新获取

1 个答案: