Lock Classe

Definição

public ref class Lock sealed

public sealed class Lock

type Lock = class

Public NotInheritable Class Lock

Herança

Object

Lock

Observações

A Lock classe pode ser usada para definir regiões de código que exigem acesso mutuamente exclusivo entre threads de um processo, comumente chamadas de secções críticas, para evitar acessos concorrentes a um recurso. A Lock pode ser introduzido e sair, onde a região de código entre o enter e o exit é uma secção crítica associada ao bloqueio. Diz-se que uma fiação que entra numa fechadura segura ou possui a fechadura até sair da fechadura. No máximo, um fio pode segurar um cadeado a qualquer momento. Uma rosca pode conter várias fechaduras. Um thread pode entrar numa fechadura várias vezes antes de sair dela, como recursivamente. Um thread que não pode entrar imediatamente num bloqueio pode esperar até que o bloqueio possa ser aberto ou até que um timeout especificado expire.

Ao usar os Enter métodos ou TryEnter para abrir uma fechadura:

• Certifique-se de que a thread sai do bloqueio de Exit forma uniforme em caso de exceções, como em C#, usando um try/finally bloco.
• Quando a fechadura está a ser introduzida e saída num método C# async , certifique-se de que não await há espaço entre a entrada e a saída. Os bloqueios são mantidos por threads e o código que se segue await pode correr numa thread diferente.

Recomenda-se usar o EnterScope método com uma construção de linguagem que elimine automaticamente o retorno Lock.Scope , como a palavra-chave C# using , ou usar a palavra-chave C# lock , pois estes garantem que o bloqueio é encerrado em casos excecionais. Estes padrões também podem ter benefícios de desempenho em relação ao uso Enter/TryEnter de e Exit. O seguinte fragmento de código ilustra vários padrões para entrar e sair de uma fechadura.

public sealed class ExampleDataStructure
{
    private readonly Lock _lockObj = new();

    public void Modify()
    {
        lock (_lockObj)
        {
            // Critical section associated with _lockObj
        }

        using (_lockObj.EnterScope())
        {
            // Critical section associated with _lockObj
        }

        _lockObj.Enter();
        try
        {
            // Critical section associated with _lockObj
        }
        finally { _lockObj.Exit(); }

        if (_lockObj.TryEnter())
        {
            try
            {
                // Critical section associated with _lockObj
            }
            finally { _lockObj.Exit(); }
        }
    }
}

Ao usar a palavra-chave C# lock ou semelhante para entrar e sair de um bloqueio, o tipo da expressão deve ser precisamente System.Threading.Lock. Se o tipo da expressão for qualquer outro, como Object ou um tipo genérico como T, pode ser usada uma implementação diferente que não seja intercambiável (como Monitor). Para mais informações, consulte a especificação relevante do compilador.

Interrupt pode interromper threads que estão à espera de entrar num bloqueio. Em threads STA do Windows, as esperas por bloqueios permitem o pump de mensagens que pode executar outro código no mesmo thread durante uma espera. Algumas funcionalidades das esperas podem ser substituídas por um personalizado SynchronizationContext.