Lock Clase

Definición

public ref class Lock sealed

public sealed class Lock

type Lock = class

Public NotInheritable Class Lock

Herencia

Object

Lock

Comentarios

La Lock clase se puede usar para definir regiones de código que requieren acceso mutuamente excluyente entre subprocesos de un proceso, denominados secciones críticas, para evitar accesos simultáneos a un recurso. Se Lock puede introducir y salir, donde la región de código entre la entrada y la salida es una sección crítica asociada al bloqueo. Se dice que un subproceso que entra en un bloqueo contiene o posee el bloqueo hasta que sale del bloqueo. Como máximo, un subproceso puede contener un bloqueo en un momento dado. Un subproceso puede contener varios bloqueos. Un subproceso puede entrar en un bloqueo varias veces antes de salir de él, como recursivamente. Un subproceso que no puede entrar en un bloqueo inmediatamente puede esperar hasta que se pueda introducir el bloqueo o hasta que expire un tiempo de espera especificado.

Al usar los Enter métodos o TryEnter para escribir un bloqueo:

• Asegúrese de que el subproceso sale del bloqueo incluso Exit en caso de excepciones, como en C# mediante un try/finally bloque .
• Cuando se introduce y sale el bloqueo en un método de C# async , asegúrese de que no haya entre await entrar y salir. Los bloqueos se mantienen en subprocesos y el código siguiente await podría ejecutarse en otro subproceso.

Se recomienda usar el EnterScope método con una construcción de lenguaje que elimine automáticamente el devuelto Lock.Scope , como la palabra clave de C# using , o para usar la palabra clave de C# lock , ya que garantizan que el bloqueo se salga en casos excepcionales. Estos patrones también pueden tener ventajas de rendimiento sobre el uso Enter/TryEnter de y Exit. En el fragmento de código siguiente se muestran varios patrones para entrar y salir de un bloqueo.

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

Al usar la palabra clave de C# lock o similar a entrar y salir de un bloqueo, el tipo de la expresión debe ser precisamente System.Threading.Lock. Si el tipo de la expresión es cualquier otra cosa, como Object o un tipo genérico como T, se puede usar una implementación diferente que no sea intercambiable en su lugar (como Monitor). Para obtener más información, consulte el speclet del compilador pertinente.

Interrupt puede interrumpir los subprocesos que están esperando entrar en un bloqueo. En Windows subprocesos STA, espera a que los bloqueos permitan el bombeo de mensajes que pueden ejecutar otro código en el mismo subproceso durante una espera. Algunas características de las esperas se pueden invalidar mediante un personalizado SynchronizationContext.