Lock Classe

Definição

public ref class Lock sealed

public sealed class Lock

type Lock = class

Public NotInheritable Class Lock

Herança

Object

Lock

Comentários

A Lock classe pode ser usada para definir regiões de código que exigem acesso mutuamente exclusivo entre threads de um processo, normalmente chamado de seções críticas, para impedir acessos simultâneos a um recurso. Uma Lock pode ser inserida e encerrada, em que a região do código entre a entrada e a saída é uma seção crítica associada ao bloqueio. Um thread que insere um bloqueio é dito para manter ou possuir o bloqueio até que ele saia do bloqueio. No máximo, um thread pode manter um bloqueio a qualquer momento. Um thread pode conter vários bloqueios. Um thread pode inserir um bloqueio várias vezes antes de sair dele, como recursivamente. Um thread que não pode inserir um bloqueio imediatamente pode aguardar até que o bloqueio possa ser inserido ou até que um tempo limite especificado expire.

Ao usar os Enter métodos ou TryEnter para inserir um bloqueio:

• Verifique se o thread sai do bloqueio mesmo Exit em caso de exceções, como em C# usando um try/finally bloco.
• Quando o bloqueio estiver sendo inserido e encerrado em um método C# async , verifique se não há nenhum await entre a entrada e a saída. Os bloqueios são mantidos por threads e o código a seguir await pode ser executado em um thread diferente.

É recomendável usar o EnterScope método com um constructo de linguagem que descarta automaticamente o retornado Lock.Scope , como a palavra-chave C# using , ou usar a palavra-chave C# lock , pois eles garantem que o bloqueio seja encerrado em casos excepcionais. Esses padrões também podem ter benefícios de desempenho em vez de usar Enter/TryEnter e Exit. O fragmento de código a seguir ilustra vários padrões para entrar e sair de um bloqueio.

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 inserir e sair de um bloqueio, o tipo da expressão deve ser precisamente System.Threading.Lock. Se o tipo da expressão for qualquer outra coisa, como Object ou um tipo genérico como T, uma implementação diferente que não seja intercambiável poderá ser usada em vez disso (como Monitor). Para obter mais informações, consulte o espectro do compilador relevante.

Interrupt pode interromper threads que estão aguardando para inserir um bloqueio. Em Windows threads sta, esperas por bloqueios permitem o bombeamento de mensagens que podem executar outro código no mesmo thread durante uma espera. Alguns recursos das esperas podem ser substituídos por um personalizado SynchronizationContext.