lock, instruction (référence C#)
Le mot clé lock marque un bloc d'instructions comme section critique en assurant le verrouillage par exclusion mutuelle d'un objet particulier, en exécutant une instruction, puis en annulant le verrouillage. L'exemple suivant inclut une instruction d' lock .
class Account
{
decimal balance;
private Object thisLock = new Object();
public void Withdraw(decimal amount)
{
lock (thisLock)
{
if (amount > balance)
{
throw new Exception("Insufficient funds");
}
balance -= amount;
}
}
}
Pour plus d'informations, consultez Synchronisation des threads (C# et Visual Basic).
Notes
Le mot clé lock permet de garantir qu'un thread n'entre pas dans une section critique de code pendant qu'un autre thread est dans la section critique . Si un autre thread tente d'entrer dans un code verrouillé, il attendra, bloquera, jusqu'à ce que l'objet soit libéré.
La section Threads (C# et Visual Basic) traite du threading.
Le mot clé lock appelle Enter au début du bloc et Exit à la fin du bloc. ThreadInterruptedException est levée si Interrupt interrompt un thread qui attend pour écrire une instruction d' lock .
En général, évitez de verrouiller un type public, ou des instances échappant au contrôle de votre code. Les constructions courantes lock (this), lock (typeof (MyType)) et lock ("myLock") violent cette directive :
lock (this) pose problème s'il est possible d'accéder publiquement à l'instance.
lock (typeof (MyType)) pose problème s'il est possible d'accéder publiquement à MyType.
lock("myLock") pose problème puisque tout autre code du processus utilisant la même chaîne partagera le même verrouillage.
La méthode conseillée consiste à définir un objet private à verrouiller, ou une variable objet private static pour protéger des données communes à toutes les instances.
Vous ne pouvez pas utiliser le mot clé d' attendez dans le corps d'une instruction d' lock .
Exemple
L'exemple suivant montre une utilisation simple des threads sans verrouillage 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
L'exemple suivant utilise des threads et lock. Tant que l'instruction lock est présente, le bloc d'instructions est une section critique et balance ne deviendra jamais un nombre négatif.
// 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 never is 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();
}
}
}
Spécification du langage C#
Pour plus d'informations, voir la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.
Voir aussi
Référence
Mots clés d'instruction (Référence C#)
Synchronisation des threads (C# et Visual Basic)