Compartir a través de


lock (Instrucción, Referencia de C#)

Actualización: noviembre 2007

La palabra clave lock marca un bloque de instrucciones como una sección crucial, para lo cual utiliza el bloqueo de exclusión mutua de un objeto, la ejecución de una instrucción y, posteriormente, la liberación del bloqueo. La instrucción presenta la siguiente forma:

Object thisLock = new Object();
lock (thisLock)
{
    // Critical code section.
}

Para obtener más información, vea Sincronización de subprocesos (Guía de programación de C#).

Comentarios

La palabra clave lock garantiza que un subproceso no va a entrar en una sección crítica del código mientras otro subproceso se encuentre ya en esta sección. Si otro subproceso intenta entrar en un código bloqueado, esperará, o se bloqueará, hasta que el objeto se libere.

En la sección Subprocesamiento (Guía de programación de C#) se describe el subprocesamiento.

La palabra clave lock llama a Enter al principio del bloque y a Exit al final del bloque.

En general evite bloquear un tipo public o instancias que estén fuera del control de su código. Las construcciones comunes lock (this), lock (typeof (MyType)) y lock ("myLock") incumplen esta instrucción:

  • lock (this) se convierte en un problema si la instancia es accesible públicamente.

  • lock (typeof (MyType)) se convierte en un problema si MyType es accesible públicamente.

  • lock(“myLock”) se convierte en un problema puesto que cualquier otro código del proceso que utilice la misma cadena compartirá el mismo bloqueo.

El procedimiento recomendado es definir un objeto un objeto private para realizar el bloqueo o una variable de objeto private static para proteger los datos comunes a todas las instancias.

Ejemplo

El siguiente ejemplo muestra un uso simple de subprocesos sin bloquear en C#.

//using System.Threading;

class ThreadTest
{
    public void RunMe()
    {
        Console.WriteLine("RunMe called");
    }

    static void Main()
    {
        ThreadTest b = new ThreadTest();
        Thread t = new Thread(b.RunMe);
        t.Start();
    }
}
// Output: RunMe called

El siguiente ejemplo utiliza subprocesos y lock. Con el uso de la instrucción lock, el bloque de instrucciones se convierte en una sección crítica y balance nunca tomará un valor negativo.

// using System.Threading;

class Account
{
    private Object thisLock = new Object();
    int balance;

    Random r = new Random();

    public Account(int initial)
    {
        balance = initial;
    }

    int Withdraw(int amount)
    {

        // This condition will never be true unless the lock statement
        // is commented out:
        if (balance < 0)
        {
            throw new Exception("Negative Balance");
        }

        // Comment out the next line to see the effect of leaving out 
        // the lock keyword:
        lock (thisLock)
        {
            if (balance >= amount)
            {
                Console.WriteLine("Balance before Withdrawal :  " + balance);
                Console.WriteLine("Amount to Withdraw        : -" + amount);
                balance = balance - amount;
                Console.WriteLine("Balance after Withdrawal  :  " + balance);
                return amount;
            }
            else
            {
                return 0; // transaction rejected
            }
        }
    }

    public void DoTransactions()
    {
        for (int i = 0; i < 100; i++)
        {
            Withdraw(r.Next(1, 100));
        }
    }
}

class Test
{
    static void Main()
    {
        Thread[] threads = new Thread[10];
        Account acc = new Account(1000);
        for (int i = 0; i < 10; i++)
        {
            Thread t = new Thread(new ThreadStart(acc.DoTransactions));
            threads[i] = t;
        }
        for (int i = 0; i < 10; i++)
        {
            threads[i].Start();
        }
    }
}

Especificación del lenguaje C#

Para obtener más información, vea las secciones siguientes de Especificación del lenguaje C#.

  • 5.3.3.18 Instrucciones Lock

  • 8.12 La instrucción lock

Vea también

Tareas

Ejemplo Monitor Synchronization Technology

Ejemplo Wait Synchronization Technology

Conceptos

Guía de programación de C#

Monitores

Operaciones de bloqueo

AutoResetEvent

Referencia

Subprocesamiento (Guía de programación de C#)

Palabras clave de C#

Palabras clave de instrucciones (Referencia de C#)

MethodImplAttributes

Mutex

Sincronización de subprocesos (Guía de programación de C#)

Otros recursos

Referencia de C#