Verrou récursif (Mutex) vs Verrou non récursif (Mutex)

POSIX permet aux mutex d'être récursifs. Cela signifie que le même thread peut verrouiller le même mutex deux fois et ne sera pas bloqué. Bien sûr, il doit également le déverrouiller deux fois, sinon aucun autre thread ne peut obtenir le mutex. Tous les systèmes prenant en charge les pthreads ne prennent pas également en charge les mutex récursifs, mais s'ils veulent être conformes à POSIX, ils doivent le faire .

D'autres API (API de plus haut niveau) proposent également généralement des mutex, souvent appelés Locks. Certains systèmes / langages (par exemple Cocoa Objective-C) offrent à la fois des mutex récursifs et non récursifs. Certaines langues n'offrent également que l'une ou l'autre. Par exemple, en Java, les mutex sont toujours récursifs (le même thread peut se "synchroniser" deux fois sur le même objet). En fonction des autres fonctionnalités de thread qu'ils offrent, ne pas avoir de mutex récursifs pourrait ne pas poser de problème, car ils peuvent facilement être écrits vous-même (j'ai déjà implémenté des mutex récursifs moi-même sur la base d'opérations mutex / condition plus simples).

Ce que je ne comprends pas vraiment: à quoi servent les mutex non récursifs? Pourquoi voudrais-je avoir un blocage de thread s'il verrouille deux fois le même mutex? Même les langages de haut niveau qui pourraient éviter cela (par exemple, tester si cela va bloquer et lever une exception si c'est le cas) ne le font généralement pas. Ils laisseront le thread bloqué à la place.

Est-ce uniquement pour les cas où je le verrouille accidentellement deux fois et ne le déverrouille qu'une seule fois et dans le cas d'un mutex récursif, il serait plus difficile de trouver le problème, donc à la place, je le verrouille immédiatement pour voir où le verrou incorrect apparaît? Mais ne pourrais-je pas faire la même chose avec le retour d'un compteur de verrouillage lors du déverrouillage et dans une situation où je suis sûr que j'ai relâché le dernier verrou et que le compteur n'est pas nul, je peux lever une exception ou enregistrer le problème? Ou y a-t-il un autre cas d'utilisation plus utile de mutex non récursifs que je ne vois pas? Ou est-ce peut-être juste des performances, car un mutex non récursif peut être légèrement plus rapide qu'un mutex récursif? Cependant, j'ai testé cela et la différence n'est vraiment pas si grande.

La différence entre un mutex récursif et non récursif a à voir avec la propriété. Dans le cas d'un mutex récursif, le noyau doit garder une trace du thread qui a réellement obtenu le mutex la première fois afin de pouvoir détecter la différence entre la récursivité et un thread différent qui devrait bloquer à la place. Comme l'a souligné une autre réponse, il y a une question de surcoût supplémentaire à la fois en termes de mémoire pour stocker ce contexte et aussi des cycles nécessaires pour le maintenir.

Cependant , il y a d'autres considérations en jeu ici aussi.

Étant donné que le mutex récursif a un sentiment de propriété, le thread qui saisit le mutex doit être le même thread qui libère le mutex. Dans le cas des mutex non récursifs, il n'y a pas de sens de propriété et n'importe quel thread peut généralement libérer le mutex, quel que soit le thread qui a pris le mutex à l'origine. Dans de nombreux cas, ce type de "mutex" est en réalité plus une action de sémaphore, où vous n'utilisez pas nécessairement le mutex comme un dispositif d'exclusion mais l'utilisez comme dispositif de synchronisation ou de signalisation entre deux ou plusieurs threads.

Une autre propriété qui vient avec un sentiment de propriété dans un mutex est la capacité de prendre en charge l'héritage prioritaire. Étant donné que le noyau peut suivre le thread propriétaire du mutex ainsi que l'identité de tous les bloqueurs, dans un système threadé prioritaire, il devient possible d'élever la priorité du thread qui possède actuellement le mutex à la priorité du thread de priorité la plus élevée qui bloque actuellement sur le mutex. Cet héritage évite le problème d'inversion de priorité qui peut se produire dans de tels cas. (Notez que tous les systèmes ne prennent pas en charge l'héritage de priorité sur de tels mutex, mais c'est une autre fonctionnalité qui devient possible via la notion de propriété).

Si vous vous référez au noyau VxWorks RTOS classique, ils définissent trois mécanismes:

• mutex - prend en charge la récursivité et éventuellement l'héritage de priorité. Ce mécanisme est couramment utilisé pour protéger de manière cohérente des sections critiques de données.
• sémaphore binaire - pas de récursivité, pas d'héritage, exclusion simple, preneur et donneur ne doivent pas nécessairement être le même fil, version de diffusion disponible Ce mécanisme peut être utilisé pour protéger des sections critiques, mais il est également particulièrement utile pour une signalisation cohérente ou une synchronisation entre threads.
• comptage de sémaphore - pas de récursivité ni d'héritage, agit comme un compteur de ressources cohérent à partir de tout compte initial souhaité, les threads ne bloquent que lorsque le compte net par rapport à la ressource est égal à zéro.

Encore une fois, cela varie quelque peu selon la plate-forme - en particulier ce qu'ils appellent ces choses, mais cela devrait être représentatif des concepts et des divers mécanismes en jeu.

La réponse n'est pas l' efficacité. Les mutex non réentrants conduisent à un meilleur code.

Exemple: A :: foo () acquiert le verrou. Il appelle ensuite B :: bar (). Cela a bien fonctionné lorsque vous l'avez écrit. Mais quelque temps plus tard, quelqu'un change B :: bar () pour appeler A :: baz (), qui acquiert également le verrou.

Eh bien, si vous n'avez pas de mutex récursifs, cette impasse. Si vous en avez, il fonctionne, mais il peut se casser. A :: foo () peut avoir laissé l'objet dans un état incohérent avant d'appeler bar (), en supposant que baz () ne peut pas être exécuté car il acquiert également le mutex. Mais il ne devrait probablement pas fonctionner! La personne qui a écrit A :: foo () a supposé que personne ne pouvait appeler A :: baz () en même temps - c'est la raison pour laquelle ces deux méthodes ont acquis le verrou.

Le bon modèle mental pour l'utilisation des mutex: Le mutex protège un invariant. Lorsque le mutex est maintenu, l'invariant peut changer, mais avant de libérer le mutex, l'invariant est rétabli. Les verrous réentrants sont dangereux car la deuxième fois que vous acquérez le verrou, vous ne pouvez plus être sûr que l'invariant est vrai.

Si vous êtes satisfait des verrous réentrants, c'est uniquement parce que vous n'avez pas eu à déboguer un problème comme celui-ci auparavant. Java a des verrous non réentrants ces jours-ci dans java.util.concurrent.locks, d'ailleurs.

Comme l'écrit Dave Butenhof lui - même :

"Le plus gros de tous les gros problèmes avec les mutex récursifs est qu'ils vous encouragent à perdre complètement votre schéma de verrouillage et votre portée. C'est mortel. Mal. C'est le" mangeur de fil ". Vous maintenez les verrous pour le temps le plus court possible. Période. Toujours. Si vous appelez quelque chose avec un cadenas maintenu simplement parce que vous ne savez pas qu'il est tenu, ou parce que vous ne savez pas si l'appelé a besoin du mutex, alors vous le tenez trop longtemps. Vous êtes en visant votre application avec un fusil à pompe et en appuyant sur la gâchette. Vous avez probablement commencé à utiliser des threads pour obtenir la concurrence, mais vous venez de PRÉVENIR la concurrence. "

Le bon modèle mental pour l'utilisation des mutex: Le mutex protège un invariant.

Pourquoi êtes-vous sûr que c'est vraiment le bon modèle mental pour l'utilisation de mutex? Je pense que le bon modèle protège les données mais pas les invariants.

Le problème de la protection des invariants se présente même dans les applications à un seul thread et n'a rien de commun avec le multi-threading et les mutex.

De plus, si vous devez protéger les invariants, vous pouvez toujours utiliser un sémaphore binaire qui n'est jamais récursif.

Une des principales raisons pour lesquelles les mutex récursifs sont utiles est en cas d'accès aux méthodes plusieurs fois par le même thread. Par exemple, disons que si le verrouillage mutex protège une banque A / C pour se retirer, alors s'il y a des frais également associés à ce retrait, alors le même mutex doit être utilisé.

Le seul bon cas d'utilisation du mutex de récursivité est lorsqu'un objet contient plusieurs méthodes. Lorsque l'une des méthodes modifie le contenu de l'objet et doit donc verrouiller l'objet avant que l'état ne soit à nouveau cohérent.

Si les méthodes utilisent d'autres méthodes (par exemple: addNewArray () appelle addNewPoint () et se termine avec recheckBounds ()), mais que l'une de ces fonctions par elle-même doit verrouiller le mutex, alors le mutex récursif est gagnant-gagnant.

Pour tout autre cas (résoudre juste un mauvais codage, l'utiliser même dans différents objets) est clairement faux!

À quoi servent les mutex non récursifs?

Ils sont absolument bons lorsque vous devez vous assurer que le mutex est déverrouillé avant de faire quelque chose. C'est parce que pthread_mutex_unlockpeut garantir que le mutex est déverrouillé uniquement s'il est non récursif.

pthread_mutex_t      g_mutex;

void foo()
{
    pthread_mutex_lock(&g_mutex);
    // Do something.
    pthread_mutex_unlock(&g_mutex);

    bar();
}

Si g_mutexn'est pas récursif, le code ci-dessus est garanti pour appeler bar()avec le mutex déverrouillé .

Éliminant ainsi la possibilité d'une impasse en cas bar() il se trouverait une fonction externe inconnue qui pourrait bien faire quelque chose qui pourrait amener un autre thread à essayer d'acquérir le même mutex. De tels scénarios ne sont pas rares dans les applications construites sur des pools de threads et dans les applications distribuées, où un appel interprocessus peut engendrer un nouveau thread sans que le programmeur client ne s'en rende compte. Dans tous ces scénarios, il est préférable d'appeler lesdites fonctions externes uniquement après le déverrouillage.

Si g_mutexc'était récursif, il n'y aurait tout simplement aucun moyen de s'assurer qu'il est déverrouillé avant de passer un appel.