lock, instruction (Informations de référence sur C#)lock Statement (C# Reference)

Le mot clé lock marque un bloc d’instructions comme étant une section critique en obtenant le verrou d’exclusion mutuelle pour un objet donné, en exécutant une instruction, puis en libérant le verrou.The lock keyword marks a statement block as a critical section by obtaining the mutual-exclusion lock for a given object, executing a statement, and then releasing the lock. L’exemple suivant inclut une instruction lock.The following example includes a lock statement.

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.For more information, see Thread Synchronization.

NotesRemarks

Le mot clé lock garantit qu’un thread n’entre pas dans une section critique de code alors qu’un autre thread est dans cette section critique.The lock keyword ensures that one thread does not enter a critical section of code while another thread is in the critical section. Si un autre thread tente d’entrer dans un code verrouillé, il attend, en restant bloqué jusqu’à ce que l’objet soit libéré.If another thread tries to enter a locked code, it will wait, block, until the object is released.

La section Threading présente le threading.The section Threading discusses threading.

Le mot clé lock appelle Enter au début du bloc et Exit à la fin du bloc.The lock keyword calls Enter at the start of the block and Exit at the end of the block. Une exception ThreadInterruptedException est levée si Interrupt interrompt un thread qui attend de passer une instruction lock.A ThreadInterruptedException is thrown if Interrupt interrupts a thread that is waiting to enter a lock statement.

D’une façon générale, évitez de verrouiller sur un type public ou sur des instances qui sont au-delà du contrôle de votre code.In general, avoid locking on a public type, or instances beyond your code's control. Les constructions courantes lock (this), lock (typeof (MyType)) et lock ("myLock") enfreignent cette directive :The common constructs lock (this), lock (typeof (MyType)), and lock ("myLock") violate this guideline:

  • lock (this) est un problème si l’instance est accessible publiquement.lock (this) is a problem if the instance can be accessed publicly.

  • lock (typeof (MyType)) est un problème si MyType est accessible publiquement.lock (typeof (MyType)) is a problem if MyType is publicly accessible.

  • lock("myLock") est un problème, car tout autre code dans le processus utilisant la même chaîne partagera le même verrou.lock("myLock") is a problem because any other code in the process using the same string, will share the same lock.

La bonne pratique consiste à définir un objet private à verrouiller, ou une variable objet private static pour protéger les données communes à toutes les instances.Best practice is to define a private object to lock on, or a private static object variable to protect data common to all instances.

Vous ne pouvez pas utiliser le mot clé await dans le corps d’une instruction lock.You can't use the await keyword in the body of a lock statement.

ExempleExample

L’exemple suivant montre une utilisation simple des threads sans verrouillage en C#.The following sample shows a simple use of threads without locking in 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

ExempleExample

L’exemple suivant utilise des threads et lock.The following sample uses threads and lock. Tant que l’instruction lock est présente, le bloc d’instructions est une section critique et balance ne devient jamais un nombre négatif.As long as the lock statement is present, the statement block is a critical section and balance will never become a negative number.

// 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();
        }
        
        //block main thread until all other threads have ran to completion.
        foreach (var t in threads)
            t.Join();
    }
}

Spécification du langage C#C# Language Specification

Pour plus d'informations, voir la spécification du langage C#.For more information, see the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Voir aussiSee Also

MethodImplAttributes
Mutex
Référence C#C# Reference
Guide de programmation C#C# Programming Guide
ThreadThreading
Mots clés C#C# Keywords
Mots clés d’instructionsStatement Keywords
Monitor
Opérations verrouilléesInterlocked Operations
AutoResetEventAutoResetEvent
Synchronisation des threadsThread Synchronization