Charge CPU Massive en utilisant std:: lock (c++11)

mes récents efforts pour implémenter un gestionnaire thread/ mutex se sont soldés par une charge CPU de 75% (4 core), alors que les quatre threads en cours d'exécution étaient soit en sommeil, soit en attente d'un mutex déverrouillé.

la classe spécifique est beaucoup trop grande pour être affiché ici entièrement, mais je pourrais réduire la cause à l'impasse-acquisition sécuritaire de deux mutex

std::unique_lock<std::mutex> lock1( mutex1, std::defer_lock );
std::unique_lock<std::mutex> lock2( mutex2, std::defer_lock );
std::lock( lock1, lock2 );

une Autre partie de la classe utilise un std::condition_variable avec wait() et notify_one() sur mutex1 pour un peu de code pour être exécuté de manière sélective dans le même temps.

Le simple fait de changer de

std::unique_lock<std::mutex> lock1( mutex1 );
std::unique_lock<std::mutex> lock2( mutex2 );

a ramené L'utilisation CPU à la normale 1-2%.

Je ne peux pas croire, la fonction std::lock() est aussi inefficace. Cela pourrait-il être un bug dans g++ 4.6.3?

edit: ( exemple )

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

std::mutex mutex1, mutex2;
std::condition_variable cond_var;

bool cond = false, done = false;

using namespace std::chrono_literals;

void Take_Locks()
    {
    while( !done )
        {
        std::this_thread::sleep_for( 1s );

        std::unique_lock<std::mutex> lock1( mutex1, std::defer_lock );
        std::unique_lock<std::mutex> lock2( mutex2, std::defer_lock );
        std::lock( lock1, lock2 );

        std::this_thread::sleep_for( 1s );
        lock1.unlock();
        lock2.unlock();
        }
    }

void Conditional_Code()
    {
    std::unique_lock<std::mutex> lock1( mutex1, std::defer_lock );
    std::unique_lock<std::mutex> lock2( mutex2, std::defer_lock );

    std::lock( lock1, lock2 );
    std::cout << "t4: waiting n";

    while( !cond )
        cond_var.wait( lock1 );

    std::cout << "t4: condition met n";
    }

int main()
    {
    std::thread t1( Take_Locks ), t2( Take_Locks ), t3( Take_Locks );
    std::thread t4( Conditional_Code );

    std::cout << "threads started n";
    std::this_thread::sleep_for( 10s );

    std::unique_lock<std::mutex> lock1( mutex1 );
    std::cout << "mutex1 locked n" ;
    std::this_thread::sleep_for( 5s );

    std::cout << "setting condition/notify n";
    cond = true;
    cond_var.notify_one();
    std::this_thread::sleep_for( 5s );

    lock1.unlock();
    std::cout << "mutex1 unlocked n";
    std::this_thread::sleep_for( 6s );

    done = true;
    t4.join(); t3.join(); t2.join(); t1.join();
    }