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 de threads (Guide de programmation C#).
Notes
lock permet de s'assurer qu'un thread n'entre pas dans une section critique du code pendant qu'un autre thread s'y trouve. Si un autre thread tente d'entrer dans un code verrouillé, il attendra, bloquera, jusqu'à ce que l'objet soit libéré.
La section Thread (Guide de programmation C#) traite du threading.
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 en C#.
// statements_lock.cs
using System;
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();
}
}
Sortie
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.
// statements_lock2.cs
using System;
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();
}
}
}
Spécification du langage C#
Pour plus d'informations, consultez les sections suivantes dans Spécifications du langage C#.
5.3.3.18 Instructions lock
8.12 L'instruction lock
Voir aussi
Tâches
Synchronisation de moniteurs, exemple de technologie
Synchronisation d'attente, exemple de technologie
Référence
Thread (Guide de programmation C#)
Mots clés C#
Types d'instructions (Référence C#)
MethodImplAttributes Enumeration
Synchronisation de threads (Guide de programmation C#)
Mutex
Concepts
Guide de programmation C#
Moniteurs
Opérations verrouillées
AutoResetEvent