Массивная загрузка ЦП с использованием std::lock (С++ 11)

На моей машине следующий код выводится 10 раз в секунду и потребляет почти 0 ресурсов процессора, потому что большую часть времени поток либо спит, либо блокируется заблокированным мьютексом:

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

using namespace std::chrono_literals;

std::mutex m1;
std::mutex m2;

void
f1()
{
    while (true)
    {
        std::unique_lock<std::mutex> l1(m1, std::defer_lock);
        std::unique_lock<std::mutex> l2(m2, std::defer_lock);
        std::lock(l1, l2);
        std::cout << "f1 has the two locks\n";
        std::this_thread::sleep_for(100ms);
    }
}

void
f2()
{
    while (true)
    {
        std::unique_lock<std::mutex> l2(m2, std::defer_lock);
        std::unique_lock<std::mutex> l1(m1, std::defer_lock);
        std::lock(l2, l1);
        std::cout << "f2 has the two locks\n";
        std::this_thread::sleep_for(100ms);
    }
}

int main()
{
    std::thread t1(f1);
    std::thread t2(f2);
    t1.join();
    t2.join();
}

Пример вывода:

f1 has the two locks
f2 has the two locks
f1 has the two locks
...

Я запускаю это в OS X, и приложение Activity Monitor говорит, что этот процесс использует процессор на 0,1%. Машина Intel Core i5 (4 ядра).

Я буду рад каким-либо образом скорректировать этот эксперимент, чтобы попытаться создать динамическую блокировку или чрезмерную загрузку процессора.

Обновить

Если эта программа использует чрезмерную загрузку ЦП на вашей платформе, попробуйте изменить ее на вызов ::lock() вместо этого, где это определяется с помощью:

template <class L0, class L1>
void
lock(L0& l0, L1& l1)
{
    while (true)
    {
        {
            std::unique_lock<L0> u0(l0);
            if (l1.try_lock())
            {
                u0.release();
                break;
            }
        }
        std::this_thread::yield();
        {
            std::unique_lock<L1> u1(l1);
            if (l0.try_lock())
            {
                u1.release();
                break;
            }
        }
        std::this_thread::yield();
    }
}

Мне было бы интересно узнать, если бы это имело какое-либо значение для вас, спасибо.

Обновление 2

После долгой задержки я написал первый набросок статьи на эту тему. В документе сравниваются 4 различных способа выполнения этой работы. Он содержит программное обеспечение, которое вы можете скопировать и вставить в свой собственный код и протестировать самостоятельно (и, пожалуйста, сообщите, что вы найдете!):

http://howardhinnant.github.io/dining_philosophers.html

Как сказано в документации, [t]объекты блокируются неопределенной последовательностью вызовов lock, try_lock, unlock. Просто не может быть эффективного способа, если мьютексы удерживаются другими потоками в течение значительного периода времени. Функция не может ждать без вращения.

std::lock() Функция, не являющаяся членом, может вызвать проблемы с динамической блокировкой или снижение производительности, она гарантирует только "Никогда не блокируется".

Если вы можете определить «порядок блокировки (иерархия блокировки)» нескольких мьютексов по дизайну, предпочтительно не использовать общий std::lock(), а блокировать каждый мьютекс в заранее определенном порядке.

Дополнительные сведения см. в разделе Получение нескольких блокировок без взаимоблокировок. деталь.

Во-первых, я хочу поблагодарить за все ответы.

В процессе работы над примером кода, воспроизводящего эффект, я обнаружил источник неприятностей.

Условная часть блокирует оба мьютекса, в то время как для функции std::condition_variable::wait() используется только один.

Но мне все равно интересно, что происходит за кулисами, что вызывает такую ​​высокую нагрузку на процессор.