Lock Classe

Définition

Espace de noms:

System.Threading

Assembly:

System.Runtime.dll

Source:

Lock.cs

Notes

Pour utiliser cette API en préversion, vous devez activer les fonctionnalités d’évaluation dans votre projet en définissant la propriété EnablePreviewFeatures sur True dans votre fichier projet. Pour plus d’informations, consultez https://aka.ms/dotnet-preview-features.

Fournit un mécanisme permettant d’obtenir une exclusion mutuelle dans les régions de code entre différents threads.

public ref class Lock sealed

[System.Runtime.Versioning.RequiresPreviewFeatures]
public sealed class Lock

[<System.Runtime.Versioning.RequiresPreviewFeatures>]
type Lock = class

Public NotInheritable Class Lock

Héritage

Object

Lock

Attributs

RequiresPreviewFeaturesAttribute

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, afin d’empêcher les accès simultanés à une ressource. Un Lock peut être entré et quitté, où la région de 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 tenir ou posséder le verrou jusqu’à ce qu’il sorte du verrou. Au maximum, un thread peut contenir un verrou à un moment donné. Un thread peut contenir plusieurs verrous. Un thread peut entrer un verrou plusieurs fois avant de le quitter, par exemple de manière récursive. Un thread qui ne peut pas entrer immédiatement un verrou peut attendre que le verrou puisse être entré ou jusqu’à ce qu’un délai d’expiration spécifié expire.

Lorsque vous utilisez les Enter méthodes ou TryEnter pour entrer un verrou :

• Assurez-vous que le thread quitte le verrou même Exit en cas d’exceptions, par exemple 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 s’exécuter await sur un autre thread.

Il est recommandé d’utiliser la EnterScope méthode avec une construction de langage qui élimine automatiquement le retournéLock.Scope, comme le mot clé C# using , ou d’utiliser le mot clé C# lock , car ceux-ci garantissent que le verrou est fermé 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 d’entrée et de sortie d’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 C# lock mot clé ou similaire pour entrer et sortir 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, par Object exemple ou un type générique comme T, une implémentation différente qui n’est pas interchangeable peut être utilisée à la place (comme Monitor). Pour plus d’informations, consultez le speclet du compilateur approprié.

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

Notes

Un thread qui entre dans un verrou, y compris plusieurs fois, par exemple de manière récursive, doit quitter le verrou le même nombre de fois pour quitter complètement le verrou et permettre à d’autres threads d’entrer dans le verrou. Si un thread se ferme en tenant un Lock, le comportement de devient Lock non défini.

Attention

Si, sur un chemin de code, un thread peut entrer plusieurs verrous avant de les quitter, assurez-vous que tous les chemins d’accès de code qui peuvent entrer deux de ces verrous sur le même thread les entrent dans le même ordre. Sinon, cela pourrait entraîner des blocages. Par exemple, considérez que sur un thread de chemin T1 de code entre lock L1 , puis lock L2 avant de quitter les deux, et sur un autre thread T2 de chemin de code entre les deux verrous dans l’ordre inverse. Dans ce scénario, il est possible que l’ordre d’événements suivant se produise : T1 entre L1, entre L2, T2T1 tente d’entrer L2 et attend, T2 tente d’entrer et tente d’entrer L1 et attend. Il existe un blocage entre T1 et T2 qui ne peut pas être résolu, et tous les autres threads qui essaient d’entrer l’un ou l’autre verrou à l’avenir se bloqueront également.

Constructeurs

Lock()

Initialise une nouvelle instance de la classe Lock.

Propriétés

IsHeldByCurrentThread

Obtient une valeur qui indique si le verrou est détenu par le thread actif.

Méthodes

Enter()	Entre dans le verrou, en attendant si nécessaire que le verrou puisse être entré.
EnterScope()	Entre dans le verrou, en attendant si nécessaire que le verrou puisse être entré.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Exit()	Quitte le verrou.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
TryEnter()	Tente d’entrer le verrou sans attendre.
TryEnter(Int32)	Tente d’entrer le verrou, en attendant si nécessaire le nombre de millisecondes spécifié jusqu’à ce que le verrou puisse être entré.
TryEnter(TimeSpan)	Tente d’entrer le verrou, en attendant si nécessaire que le verrou puisse être entré ou jusqu’à l’expiration du délai d’expiration spécifié.