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. Cette instruction prend la forme suivante :
Object thisLock = new Object();
lock (thisLock)
{
// Critical code section.
}
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.
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.
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, consultez 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)