Entendendo a restrição: aguarda e LOCK em C#

c#'s espera palavra-chave é crucial para programação assíncrona, permitindo operações não bloqueadoras. No entanto, usando aguarda dentro de um Lock A instrução é estritamente proibida. Essa restrição é uma opção de design -chave para evitar uma fonte comum de erros: Deadlocks.

A documentação da Microsoft explica que uma expressão de aguarda dentro de um Lock cria um risco. A execução do código pode pausar após o aguarda produz controle, retomando posteriormente em um encadeamento potencialmente diferente. Essa lacuna de tempo pode levar a situações em que outros threads obtêm bloqueios, revertendo a ordem de bloqueio e resultando em um impasse.

Vamos examinar um exemplo hipotético:

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); }
    }
}

Este código tenta imitar o bloqueio assíncrono, mas, como o compilador indica, é propenso a bloqueio indefinido em exitdisposable.dispose () , levando potencialmente a deadlocks. Isso acontece porque monitor.exit pode ser executado em um thread diferente daquele que adquiriu o bloqueio, potencialmente violando a ordem de bloqueio.

em essência, a proibição de aguarda dentro de Lock é uma medida proativa para evitar impasses em aplicativos multithread. É melhor evitar combinar operações assíncronas com Lock e considerar métodos alternativos de sincronização, como bloqueios de leitor-writer ou primitivos de sincronização de System.Threading .