C++11: pourquoi std::condition_variable utiliser std::unique_lock?

donc il n'y a pas de raison technique?

Je upvoted cmeerw de répondre parce que je crois qu'il a donné une raison technique. Nous allons marcher à travers elle. Imaginons que le comité avait décidé d'avoir condition_variable attendre sur un mutex. Voici le code à l'aide de cette conception:

void foo()
{
    mut.lock();
    //mut locked by this thread here
    while (not_ready)
        cv.wait(mut);
    //mut locked by this thread here
    mut.unlock();
}

C'est exactement la façon dont un ne devrait pas utiliser un condition_variable. Dans les régions marqué avec:

//mut locked by this thread here

il y a une exception problème de sécurité, et il est sérieux. Si une exception est levée dans ces domaines (ou par cv.wait lui-même), l'état verrouillé de l'mutex est une fuite à moins d'un try/catch est aussi mettre en quelque part pour intercepter l'exception et le déverrouiller. Mais c'est juste plus de code que vous demandez au programmeur d'écrire.

Disons que le programmeur sait comment écrire exception coffre-fort à code, et sait s'en servir unique_lock pour l'atteindre. Maintenant, le code ressemble à ceci:

void foo()
{
    unique_lock<mutex> lk(mut);
    //mut locked by this thread here
    while (not_ready)
        cv.wait(*lk.mutex());
    //mut locked by this thread here
}

C'est beaucoup mieux, mais il n'est toujours pas une grande situation. Le condition_variable interface est de faire le programmeur de sortir de sa façon de faire les choses à travailler. Il est possible de déréférencement de pointeur null si lk accidentellement ne fait pas référence à un mutex. Et il n'existe aucun moyen pour condition_variable::wait pour vérifier que ce thread n'propre de la serrure sur mut.

Oh, viens de me rappeler, il y a également le risque que le programmeur peut choisir le mal unique_lock fonction membre pour exposer le mutex. *lk.release() serait désastreux ici.

Regardons maintenant comment le code est écrit avec le réel condition_variable API qui prend un unique_lock<mutex>:

void foo()
{
    unique_lock<mutex> lk(mut);
    //mut locked by this thread here
    while (not_ready)
        cv.wait(lk);
    //mut locked by this thread here
}

1. Ce code est aussi simple qu'il peut obtenir.
2. C'est l'exception coffre-fort.
3. La wait fonction peut vérifier lk.owns_lock() et de lever une exception si elle est false.

Ces techniques sont les raisons qui ont conduit à la conception d'API de condition_variable.

En outre, condition_variable::wait ne pas prendre un lock_guard<mutex> parce que lock_guard<mutex> est de savoir comment vous dire: je possède le verrou sur ce mutex jusqu'à lock_guard<mutex> détruise. Mais lorsque vous appelez condition_variable::wait, vous implicitement libérer le verrou sur le mutex. De sorte que l'action est incompatible avec la lock_guard cas d'utilisation /déclaration.

Nous avons besoin unique_lock de toute façon que l'on pourrait, de retour de serrures de fonctions, de les mettre dans des conteneurs, et de verrouiller/déverrouiller les mutex hors de portée des modèles dans une exception en toute sécurité, de sorte unique_lock était le choix naturel pour condition_variable::wait.

Mise à jour

bamboon suggéré dans les commentaires ci-dessous que j'ai contraste condition_variable_any, voilà:

Question: Pourquoi n'est-ce pas condition_variable::wait basé sur un modèle afin que je puisse passer toute Lockable de texte?

Réponse:

C'est vraiment cool d'avoir. Par exemple ce document montre le code qui attend une shared_lock (rwlock) en mode partagé sur une variable de condition (quelque chose inouïe dans l'posix monde, mais très utile par ailleurs). Toutefois, la fonctionnalité est plus cher.

De sorte que le comité a introduit un nouveau type avec cette fonctionnalité:

`condition_variable_any`

Avec cette condition_variable adaptateur l'on peut attendre sur tout verrouillable type. Si elle a des membres lock() et unlock(), vous êtes bon pour aller. Une bonne mise en œuvre de condition_variable_any nécessite un condition_variable membre de données et un shared_ptr<mutex> membre de données.

Parce que cette nouvelle fonctionnalité est plus cher que votre base condition_variable::wait, et parce que condition_variable de bas niveau de l'outil, très utile, mais plus cher fonctionnalité a été mis dans une classe distincte de sorte que vous ne payez que si vous l'utilisez.