Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Mutex classe

 

Date de publication : novembre 2016

Primitive de synchronisation qui peut également être utilisée pour la synchronisation entre processus.

Espace de noms:   System.Threading
Assembly:  mscorlib (dans mscorlib.dll)


[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public sealed class Mutex : WaitHandle

NomDescription
System_CAPS_pubmethodMutex()

Initialise une nouvelle instance de la classe Mutex avec des propriétés par défaut.

System_CAPS_pubmethodMutex(Boolean)

Initialise une nouvelle instance de la classe Mutex avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex.

System_CAPS_pubmethodMutex(Boolean, String)

Initialise une nouvelle instance de la classe Mutex avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex, et une chaîne représentant le nom du mutex.

System_CAPS_pubmethodMutex(Boolean, String, Boolean)

Initialise une nouvelle instance de la classe Mutex avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex, une chaîne qui représente le nom du mutex et une valeur booléenne qui, quand la méthode retourne son résultat, indique si la propriété initiale du mutex a été accordée au thread appelant.

System_CAPS_pubmethodMutex(Boolean, String, Boolean, MutexSecurity)

Initialise une nouvelle instance de la classe Mutex avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex, une chaîne qui représente le nom du mutex et une variable booléenne qui, quand la méthode retourne son résultat, indique si la propriété initiale du mutex a été accordée au thread appelant, ainsi que la sécurité de contrôle d'accès à appliquer au mutex nommé.

NomDescription
System_CAPS_pubpropertyHandle

Obsolète. Obtient ou définit le handle du système d'exploitation natif.(Hérité de WaitHandle.)

System_CAPS_pubpropertySafeWaitHandle

Obtient ou définit le handle du système d'exploitation natif.(Hérité de WaitHandle.)

NomDescription
System_CAPS_pubmethodClose()

Libère toutes les ressources détenues par le WaitHandle actuel.(Hérité de WaitHandle.)

System_CAPS_pubmethodCreateObjRef(Type)

Crée un objet qui contient toutes les informations requises pour générer un proxy permettant de communiquer avec un objet distant.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodDispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe WaitHandle.(Hérité de WaitHandle.)

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodGetAccessControl()

Obtient un objet MutexSecurity qui représente la sécurité de contrôle d'accès pour le mutex nommé.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetLifetimeService()

Récupère l’objet de service de durée de vie actuelle qui contrôle la stratégie de durée de vie de cette instance.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodInitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.(Hérité de MarshalByRefObject.)

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String)

Ouvre le mutex nommé spécifié, s'il existe déjà.

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String, MutexRights)

Ouvre le mutex nommé spécifié, s'il existe déjà, avec l'accès de sécurité souhaité.

System_CAPS_pubmethodReleaseMutex()

Libère l'objet Mutex une seule fois.

System_CAPS_pubmethodSetAccessControl(MutexSecurity)

Définit la sécurité de contrôle d'accès pour un mutex système nommé.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, Mutex)

Ouvre le mutex nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi.

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, MutexRights, Mutex)

Ouvre le mutex nommé spécifié, s'il existe déjà, avec l'accès de sécurité souhaité, puis retourne une valeur indiquant si l'opération a réussi.

System_CAPS_pubmethodWaitOne()

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal.(Hérité de WaitHandle.)

System_CAPS_pubmethodWaitOne(Int32)

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l'intervalle de temps.(Hérité de WaitHandle.)

System_CAPS_pubmethodWaitOne(Int32, Boolean)

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l'intervalle de temps et en spécifiant s'il faut quitter le domaine de synchronisation avant l'attente.(Hérité de WaitHandle.)

System_CAPS_pubmethodWaitOne(TimeSpan)

Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps.(Hérité de WaitHandle.)

System_CAPS_pubmethodWaitOne(TimeSpan, Boolean)

Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps et en spécifiant s'il faut quitter le domaine de synchronisation avant l'attente.(Hérité de WaitHandle.)

NomDescription
System_CAPS_pubmethodGetSafeWaitHandle()

Obtient le handle sécurisé pour un handle d’attente de système d’exploitation natif.(Défini par WaitHandleExtensions.)

System_CAPS_pubmethodSetSafeWaitHandle(SafeWaitHandle)

Définit un handle sécurisé pour un handle d’attente de système d’exploitation natif.(Défini par WaitHandleExtensions.)

System_CAPS_noteRemarque

Pour afficher le code source .NET Framework pour ce type, consultez la Reference Source. Vous pouvez parcourir le code source en ligne, télécharger la référence hors connexion et parcourir les sources (y compris les correctifs et mises à jour) pendant le débogage ; see instructions.

Lorsque deux ou plusieurs threads doivent accéder à une ressource partagée en même temps, le système a besoin d’un mécanisme de synchronisation pour garantir qu’un seul thread à la fois utilise la ressource. Mutex une synchronisation est primitif qui accorde l’accès exclusif à la ressource partagée à un seul thread. Si un thread acquiert un mutex, l’autre thread qui veut acquérir ce mutex est suspendue jusqu'à ce que le premier thread libère le mutex.

System_CAPS_importantImportant

Ce type implémente le IDisposable interface. Lorsque vous avez fini d'utiliser le type, vous devez supprimer de celui-ci, directement ou indirectement. Pour supprimer le type directement, appelez sa Dispose méthode dans un try/catch bloc. Pour la supprimer indirectement, utiliser une construction de langage telles que using (en c#) ou Using (en Visual Basic). Pour plus d'informations, consultez la section « Utilisant un objet qui implémente IDisposable » dans la IDisposable rubrique de l'interface.

Vous pouvez utiliser la WaitHandle.WaitOne méthode pour demander la propriété d’un mutex. Le thread appelant se bloque jusqu'à ce qu’un des éléments suivants se produit :

  • Le mutex est signalé pour indiquer qu’il n’appartient pas. Dans ce cas, le WaitOne méthode retourne true, et le thread appelant la propriété du mutex et accède à la ressource protégée par le mutex. Lorsque l’accès à la ressource est terminé, le thread doit appeler le ReleaseMutex méthode pour libérer la propriété du mutex. Le premier exemple dans la section exemples illustre ce modèle.

  • L’intervalle de délai d’attente spécifié dans l’appel à une WaitOne méthode qui a un millisecondsTimeout ou timeout paramètre soit écoulé. Dans ce cas, le WaitOne méthode retourne false, et le thread appelant ne fait aucune autre tentative d’obtention de la propriété du mutex. Dans ce cas, vous devez structurer votre code afin que l’accès à la ressource protégée par le mutex est refusé au thread appelant. Étant donné que le thread n’a jamais acquis la propriété du mutex, il ne doit pas appeler la ReleaseMutex méthode. Le deuxième exemple dans la section exemples illustre ce modèle.

La Mutex classe applique l’identité de thread, un mutex peut être libéré uniquement par le thread qui l’a obtenu. En revanche, la Semaphore classe n’applique pas l’identité de thread. Un mutex peut également être transmis au-delà des limites de domaine d’application.

Le thread qui possède un mutex peut demander ce mutex dans des appels répétés à WaitOne sans bloquer son exécution. Toutefois, le thread doit appeler le ReleaseMutex méthode autant de fois pour libérer la propriété du mutex.

Étant donné que le Mutex hérite de la classe WaitHandle, vous pouvez également appeler la méthode statique WaitHandle.WaitAll et WaitHandle.WaitAny méthodes pour synchroniser l’accès à une ressource protégée.

Si un thread se termine alors qu'il possède un mutex, le mutex est dit abandonné. L’état du mutex a la valeur signalé et le thread en attente suivant obtient la propriété. Depuis la version 2.0 du .NET Framework, un AbandonedMutexException est levée dans le thread suivant qui acquiert le mutex abandonné. Avant la version 2.0 du .NET Framework, aucune exception n’a été levée.

System_CAPS_cautionAttention

Un mutex abandonné indique souvent une erreur sérieuse dans le code. Lorsqu'un thread sort sans libérer le mutex, les structures de données protégées par le mutex ne peuvent pas être dans un état cohérent. Le thread suivant qui demande la propriété du mutex peut gérer cette exception et continuer, si l'intégrité des structures de données peut être vérifiée.

Dans le cas d'un mutex système, un mutex abandonné peut indiquer qu'une application a été arrêtée soudainement (par exemple, en utilisant le Gestionnaire des tâches Windows).

Les mutex sont de deux types : les mutex locaux, qui sont nommés et les mutex système. Un mutex local existe uniquement dans votre processus. Il peut être utilisé par tout thread de votre processus qui a une référence à la Mutex objet qui représente le mutex. Chaque sans nom Mutex objet représente un mutex local séparé.

Nommé mutex système sont visibles dans tout le système d’exploitation peuvent être utilisés pour synchroniser les activités de processus. Vous pouvez créer un Mutex objet qui représente un mutex système nommé en utilisant un constructeur qui accepte un nom. L’objet de système d’exploitation peut être créé en même temps, ou il peut exister avant la création de la Mutex objet. Vous pouvez créer plusieurs Mutex objets qui représentent le même de mutex système nommé et vous pouvez utiliser la OpenExisting mutex système nommé de méthode pour ouvrir un existant.

System_CAPS_noteRemarque

Sur un serveur qui exécute les Services Terminal Server, un mutex système nommé peut avoir deux niveaux de visibilité. Si son nom commence par le préfixe « Global\ », le mutex est visible dans toutes les sessions terminal server. Si son nom commence par le préfixe « Locale\ », le mutex est visible uniquement dans la session terminal server où il a été créé. Dans ce cas, un mutex séparé avec le même nom peut exister dans chacun des autres sessions terminal server sur le serveur. Si vous ne spécifiez pas de préfixe lorsque vous créez un mutex nommé, il prend le préfixe « Locale\ ». Dans une session terminal server, deux mutexes dont les noms diffèrent uniquement par leurs préfixes sont des mutexes séparés, et les deux sont visibles par tous les processus dans la session terminal server. Autrement dit, les noms du préfixe « Global\ » et « Locale\ » décrivent l’étendue du nom de mutex par rapport aux sessions terminal server, non pas au processus.

Cet exemple montre comment une variable locale Mutex objet est utilisé pour synchroniser l’accès à une ressource protégée. Étant donné que chaque thread d’appel est bloqué jusqu'à ce qu’il acquière la propriété du mutex, il doit appeler la ReleaseMutex méthode pour libérer la possession du thread.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name);
        mut.WaitOne();

        Console.WriteLine("{0} has entered the protected area", 
                          Thread.CurrentThread.Name);

        // Place code to access non-reentrant resources here.

        // Simulate some work.
        Thread.Sleep(500);

        Console.WriteLine("{0} is leaving the protected area", 
            Thread.CurrentThread.Name);

        // Release the Mutex.
        mut.ReleaseMutex();
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name);
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread2 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread3 is requesting the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
//       Thread3 has released the mutex
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       Thread2 has released the mutex

Dans l’exemple suivant, chaque thread appelle le WaitOne(Int32) méthode pour acquérir le mutex. Si le délai est écoulé, la méthode retourne false, et le thread acquiert le mutex ni n’accède à la ressource que le mutex protège. Le ReleaseMutex méthode est appelée uniquement par le thread qui acquiert le mutex.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        Example ex = new Example();
        ex.StartThreads();
    }

     private void StartThreads()
     {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread returns to Main and exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter, and do not enter if the request times out.
        Console.WriteLine("{0} is requesting the mutex", Thread.CurrentThread.Name);
        if (mut.WaitOne(1000)) {
           Console.WriteLine("{0} has entered the protected area", 
               Thread.CurrentThread.Name);

           // Place code to access non-reentrant resources here.

           // Simulate some work.
           Thread.Sleep(5000);

           Console.WriteLine("{0} is leaving the protected area", 
               Thread.CurrentThread.Name);

           // Release the Mutex.
              mut.ReleaseMutex();
           Console.WriteLine("{0} has released the mutex", 
                             Thread.CurrentThread.Name);
        }
        else {
           Console.WriteLine("{0} will not acquire the mutex", 
                             Thread.CurrentThread.Name);
        }
    }

    ~Example()
    {
       mut.Dispose();
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread2 is requesting the mutex
//       Thread3 is requesting the mutex
//       Thread2 will not acquire the mutex
//       Thread3 will not acquire the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight pour Windows Phone
Disponible depuis 7.1
Windows Phone
Disponible depuis 8.1

Ce type est thread-safe.

Retour au début
Afficher: