Lock Classe

Définition

public ref class Lock sealed

public sealed class Lock

type Lock = class

Public NotInheritable Class Lock

Héritage

Object

Lock

Remarques

La Lock classe peut être utilisée pour définir des régions de code qui nécessitent un accès mutuellement exclusif entre les threads d’un processus, communément appelés sections critiques, pour empêcher les accès simultanés à une ressource. Un Lock peut être entré et quitté, où la région du code entre l’entrée et la sortie est une section critique associée au verrou. Un thread qui entre dans un verrou est dit contenir ou posséder le verrou jusqu’à ce qu’il quitte le verrou. Au plus un thread peut contenir un verrou à tout moment. Un thread peut contenir plusieurs verrous. Un thread peut entrer plusieurs fois un verrou avant de le quitter, par exemple de manière récursive. Un thread qui ne peut pas entrer un verrou immédiatement peut attendre que le verrou puisse être entré ou jusqu’à ce qu’un délai d’expiration spécifié expire.

Lors de l’utilisation des méthodes ou TryEnter des Enter méthodes pour entrer un verrou :

• Assurez-vous que le thread quitte le verrou même Exit en cas d’exceptions, comme en C# à l’aide d’un try/finally bloc.
• Lorsque le verrou est entré et quitté dans une méthode C# async , assurez-vous qu’il n’y a pas await entre l’entrée et la sortie. Les verrous sont conservés par des threads et le code suivant peut await s’exécuter sur un autre thread.

Il est recommandé d’utiliser la EnterScope méthode avec une construction de langage qui supprime automatiquement le mot clé C# using retournéLock.Scope, ou d’utiliser le mot clé C#lock, car elles garantissent que le verrou est quitté dans des cas exceptionnels. Ces modèles peuvent également avoir des avantages en matière de performances par rapport à l’utilisation Enter/TryEnter et Exit. Le fragment de code suivant illustre différents modèles pour entrer et quitter un verrou.

public sealed class ExampleDataStructure
{
    private readonly Lock _lockObj = new();

    public void Modify()
    {
        lock (_lockObj)
        {
            // Critical section associated with _lockObj
        }

        using (_lockObj.EnterScope())
        {
            // Critical section associated with _lockObj
        }

        _lockObj.Enter();
        try
        {
            // Critical section associated with _lockObj
        }
        finally { _lockObj.Exit(); }

        if (_lockObj.TryEnter())
        {
            try
            {
                // Critical section associated with _lockObj
            }
            finally { _lockObj.Exit(); }
        }
    }
}

Lorsque vous utilisez le mot clé C# lock ou similaire à l’entrée et à la sortie d’un verrou, le type de l’expression doit être précisément System.Threading.Lock. Si le type de l’expression est autre chose, tel qu’un Object type générique comme T, une autre implémentation qui n’est pas interchangeable peut être utilisée à la place (par Monitorexemple). Pour plus d’informations, consultez le speclet du compilateur approprié.

Interrupt peut interrompre les threads qui attendent d’entrer un verrou. Sur Windows threads STA, les attentes pour les verrous autorisent le pompage des messages qui peuvent exécuter d’autres codes sur le même thread pendant une attente. Certaines fonctionnalités des attentes peuvent être remplacées par une commande personnalisée SynchronizationContext.