Comprendre la restriction: attendre et lock dans c #

c # 's attendre le mot clé est crucial pour la programmation asynchrone, permettant des opérations non bloquantes. Cependant, en utilisant attendre à l'intérieur d'une instruction lock est strictement interdite. Cette restriction est un choix de conception clé pour empêcher une source d'erreurs commune: des impasses.

La documentation de Microsoft explique qu'un attend l'expression dans un lock crée un risque. L'exécution du code peut s'arrêter après que le attend le contrôle, reprise plus tard sur un thread potentiellement différent. Cet écart de synchronisation peut conduire à des situations où d'autres threads obtiennent des verrous, inversant l'ordre de verrouillage et entraînant une impasse.

Examinons un exemple hypothétique:

class Async
{
    public static async Task Lock(object obj)
    {
        while (!Monitor.TryEnter(obj))
            await Task.Yield();

        return new ExitDisposable(obj);
    }

    private class ExitDisposable : IDisposable
    {
        private readonly object obj;
        public ExitDisposable(object obj) { this.obj = obj; }
        public void Dispose() { Monitor.Exit(this.obj); }
    }
}

Ce code tente d'imiter le verrouillage asynchrone, mais comme le compilateur l'indique, il est sujet au blocage indéfini dans eXitDisposable.dispose () , conduisant potentiellement à des impasses. Cela se produit parce que monitor.exit peut s'exécuter sur un fil différent de celui qui a acquis le verrou, violant potentiellement l'ordre de verrouillage.

Essence, l'interdiction sur attend dans lock est une mesure proactive pour éviter les blocs de blocage dans les applications multithread. Il est préférable d'éviter de combiner des opérations asynchrones avec des instructions verrouillez et considérez des méthodes de synchronisation alternatives telles que les verrous de lecture-écrivains ou les primitives de synchronisation de system.threading .