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
Referencia
Subprocesamiento (Guía de programación de C#)
Palabras clave de instrucciones (Referencia de C#)
Sincronización de subprocesos (Guía de programación de C#)