Mutex réentrant

En informatique, un mutex réentrant (aussi appelé mutex récursif) est une exclusion mutuelle, un mécanisme de verrouillage récursif, qui peut être bloqué plusieurs fois par le même processus ou fil (d'exécution) sans toutefois causer un interblocage.

Alors qu'un quelconque essai de bloquer un mutex ordinaire (lock) qui serait déjà en position bloquée, échouerait, cette opération sur un mutex réentrant réussit, si et seulement si le fil bloquant est déjà celui qui contient le lock. Typiquement, un mutex réentrant comptabilise le nombre de fois qu'il a été bloqué et nécessitera autant de déblocages (unlock) avant qu'un autre fil puisse le bloquer.

Motivation

Les mutex réentrants résolvent le problème de non-réentrance que l'on rencontre avec les mutex réguliers: si une fonction qui verrouillerait et exécuterait un callback, est elle-même appelée par un callback, un interblocage en résulterait. En pseudo-code, nous avons la situation suivante:

var m : Mutex  // Un mutex régulier, initialement déverrouillé.

function lock_and_call(i : Integer)
    m.lock()
    callback(i)
    m.unlock()

function callback(i : Integer)
    if i > 0
        lock_and_call(i - 1)

Données ces définitions, la fonction lock_and_call(1) causera cette séquence d'événements:

• m.lock() — mutex bloqué
• callback(1)
• lock_and_call(0) — car i > 0
• m.lock() — interblocage , car m est déjà verrouillé et par conséquent le fil va se bloquer, s'attendant lui-même.

Ainsi, on résout ce problème en remplaçant le mutex régulier par un réentrant car le dernier m.lock() va pouvoir s'accomplir sans bloquer l'exécution.