c++ - 在单独的线程 C++ 上解锁时，互斥量不会解除阻塞

Question

我试图理解为什么我的互斥锁的行为与我预期的不一样。

我正在调试另一个问题，并决定制作一个非常简单的可执行文件来直接测试互斥行为。这是我想出的:

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

int main(int argc, char** argv)
{
        std::mutex myMutex;

        auto threadGenerator = [&] (std::string printout)
        {
                auto threadFunctor = [&, printout] {

                        int count = 0;
                        while (count < 300)
                        {
                                std::lock_guard<std::mutex> lock(myMutex);


                                std::cout << printout << std::endl;
                                count++;

                                // Sleep ensures that the other thread will be waiting on mutex
                                // when I release lock
                                std::this_thread::sleep_for(std::chrono::milliseconds(10));
                        }
                };

                return threadFunctor;
        };

        auto thread1Functor = threadGenerator("Thread 1 got lock");
        auto thread2Functor = threadGenerator("Thread 2 got lock");

        std::thread thread1(thread1Functor);
        std::thread thread2(thread2Functor);

        thread1.join();
        thread2.join();

        return 0;
}

这只会产生两个重复锁定和解锁互斥锁的线程，同时打印一些输出。我添加了 sleep 以强制 lock_guard 阻塞并让线程相互等待。

这会产生以下输出:

Thread 1 got lock
Thread 1 got lock
Thread 1 got lock
Thread 1 got lock
Thread 1 got lock
Thread 1 got lock
Thread 1 got lock
Thread 1 got lock
Thread 1 got lock
Thread 1 got lock
Thread 1 got lock
Thread 1 got lock

最终，一旦线程 1 完成，线程 2 将再次开始获取锁。

他们不应该在线程 1 和线程 2 之间交替吗？锁应该在每次循环迭代结束时释放，这应该允许另一个线程控制互斥锁。为什么没有发生这种情况？有什么办法可以实现吗？

Answer 1

Shouldn't they be alternating between Thread 1 and Thread 2?

没有这样的保证。

The lock should be released at the end of each loop iteration, which should allow the other thread to take control of the mutex. Why isn't that happening?

因为您的第一个线程锁定互斥量，休眠，解锁互斥量然后再次尝试锁定互斥量。现在线程 1 和线程 2 都在尝试获取互斥锁，但是线程 1 处于运行状态，而线程 2 处于休眠状态，因此线程 1 最先获取互斥锁的可能性更大。

Is there any way to make it happen?

您的程序不应该区分线程，也不应该依赖于顺序。在实际情况下，多个线程等待互斥锁获取数据，一个线程将其放在那里，因此所有等待线程都处于等待状态，因此它们获得互斥锁的概率相似。但这可能特定于特定的硬件、操作系统和版本。您的程序不应依赖于哪个特定线程获取了互斥量。