Mutex Classe

Définition

Primitive de synchronisation qui peut également être utilisée pour la synchronisation entre processus.A synchronization primitive that can also be used for interprocess synchronization.

public ref class Mutex sealed : System::Threading::WaitHandle
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Mutex : System.Threading.WaitHandle
type Mutex = class
    inherit WaitHandle
Public NotInheritable Class Mutex
Inherits WaitHandle
Héritage
Attributs

Exemples

Cet exemple montre comment un objet Mutex local est utilisé pour synchroniser l’accès à une ressource protégée.This example shows how a local Mutex object is used to synchronize access to a protected resource. Étant donné que chaque thread appelant est bloqué jusqu’à ce qu’il acquière la propriété du mutex, ReleaseMutex il doit appeler la méthode pour libérer la propriété du thread.Because each calling thread is blocked until it acquires ownership of the mutex, it must call the ReleaseMutex method to release ownership of the 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
Imports System.Threading

Module Example
   ' Create a new Mutex. The creating thread does not own the mutex.
   Private mut As New Mutex()
   Private Const numIterations As Integer = 1
   Private Const numThreads As Integer = 3
   
   Public Sub Main()
        ' Create the threads that will use the protected resource.
        For i As Integer = 0 To numThreads - 1
            Dim newThread As New Thread(AddressOf ThreadProc)
            newThread.Name = String.Format("Thread{0}", i + 1)
            newThread.Start()
        Next

        ' The main thread exits, but the application continues to
        ' run until all foreground threads have exited.
    End Sub

    Private Sub ThreadProc()
        For i As Integer = 0 To numIterations - 1
            UseResource()
        Next
    End Sub

    ' This method represents a resource that must be synchronized
    ' so that only one thread at a time can enter.
    Private Sub 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)
   End Sub
End Module
' 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 la WaitOne(Int32) méthode pour acquérir le mutex.In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. Si l’intervalle de délai d’attente est écoulé, la méthode falseretourne et le thread n’acquiert pas le mutex et n’obtient pas l’accès à la ressource protégée par le mutex.If the time-out interval elapses, the method returns false, and the thread neither acquires the mutex nor gains access to the resource the mutex protects. La ReleaseMutex méthode est appelée uniquement par le thread qui acquiert le mutex.The ReleaseMutex method is called only by the thread that acquires the 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
Imports System.Threading

Class Example
   ' Create a new Mutex. The creating thread does not own the mutex.
   Private mut As New Mutex()
   Private Const numIterations As Integer = 1
   Private Const numThreads As Integer = 3

   Public Shared Sub Main()
      Dim ex As New Example()
      ex.StartThreads()
   End Sub
   
   Private Sub StartThreads()
        ' Create the threads that will use the protected resource.
        For i As Integer = 0 To numThreads - 1
            Dim newThread As New Thread(AddressOf ThreadProc)
            newThread.Name = String.Format("Thread{0}", i + 1)
            newThread.Start()
        Next

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

   Private Sub ThreadProc()
        For i As Integer = 0 To numIterations - 1
            UseResource()
        Next
   End Sub

   ' This method represents a resource that must be synchronized
   ' so that only one thread at a time can enter.
   Private Sub UseResource()
        ' Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name)
        If mut.WaitOne(1000) Then
           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)
        End If
   End Sub
   
   Protected Overrides Sub Finalize()
      mut.Dispose()
   End Sub
End Class
' 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

Remarques

Lorsque plusieurs threads ont besoin d’accéder à une ressource partagée en même temps, le système a besoin d’un mécanisme de synchronisation pour s’assurer qu’un seul thread à la fois utilise la ressource.When two or more threads need to access a shared resource at the same time, the system needs a synchronization mechanism to ensure that only one thread at a time uses the resource. Mutexest une primitive de synchronisation qui accorde un accès exclusif à la ressource partagée à un seul thread.Mutex is a synchronization primitive that grants exclusive access to the shared resource to only one thread. Si un thread acquiert un mutex, le deuxième thread qui souhaite acquérir ce mutex est suspendu jusqu’à ce que le premier thread libère le mutex.If a thread acquires a mutex, the second thread that wants to acquire that mutex is suspended until the first thread releases the mutex.

Important

Ce type implémente l'interface IDisposable.This type implements the IDisposable interface. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement.When you have finished using the type, you should dispose of it either directly or indirectly. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Vous pouvez utiliser la WaitHandle.WaitOne méthode pour demander la propriété d’un mutex.You can use the WaitHandle.WaitOne method to request ownership of a mutex. Le thread appelant se bloque jusqu’à ce que l’un des éléments suivants se produise :The calling thread blocks until one of the following occurs:

  • Le mutex est signalé pour indiquer qu’il n’est pas détenu.The mutex is signaled to indicate that it is not owned. Dans ce cas, la WaitOne méthode retourne trueet le thread appelant assume la propriété du mutex et accède à la ressource protégée par le mutex.When this happens, the WaitOne method returns true, and the calling thread assumes ownership of the mutex and accesses the resource protected by the mutex. Lorsqu’il a terminé d’accéder à la ressource, le thread doit appeler ReleaseMutex la méthode pour libérer la propriété du mutex.When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. Le premier exemple de la section exemples illustre ce modèle.The first example in the Examples section illustrates this pattern.

  • L’intervalle de délai d’attente spécifié dans l’appel à WaitOne une méthode qui a millisecondsTimeout un timeout paramètre ou a expiré.The time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. Dans ce cas, la WaitOne méthode retourne falseet le thread appelant ne tente pas d’acquérir la propriété du mutex.When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. Dans ce cas, vous devez structurer votre code pour que l’accès à la ressource protégée par le mutex soit refusé au thread appelant.In this case, you should structure your code so that access to the resource that is protected by the mutex is denied to the calling thread. Étant donné que le thread n’a jamais acquis la propriété du mutex, il ReleaseMutex ne doit pas appeler la méthode.Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. Le deuxième exemple de la section exemples illustre ce modèle.The second example in the Examples section illustrates this pattern.

La Mutex classe applique l’identité de thread, donc un mutex peut être libéré uniquement par le thread qui l’a acquis.The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. En revanche, la Semaphore classe n’applique pas l’identité des threads.By contrast, the Semaphore class does not enforce thread identity. Un mutex peut également être passé au-delà des limites du domaine d’application.A mutex can also be passed across application domain boundaries.

Le thread qui possède un mutex peut demander le même Mutex dans des appels répétés à WaitOne sans bloquer son exécution.The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. Toutefois, le thread doit appeler la ReleaseMutex méthode le même nombre de fois pour libérer la propriété du mutex.However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

Étant donné Mutex que la classe hérite de WaitHandle, vous pouvez également appeler WaitHandle.WaitAll les WaitHandle.WaitAny méthodes et statiques pour synchroniser l’accès à une ressource protégée.Because the Mutex class inherits from WaitHandle, you can also call the static WaitHandle.WaitAll and WaitHandle.WaitAny methods to synchronize access to a protected resource.

Si un thread se termine alors qu’il est propriétaire d’un mutex, le mutex est considéré comme abandonné.If a thread terminates while owning a mutex, the mutex is said to be abandoned. L’état du mutex est défini sur signalé et le thread en attente suivant obtient la propriété.The state of the mutex is set to signaled, and the next waiting thread gets ownership. À compter de la version 2,0 du .NET Framework, AbandonedMutexException une exception est levée dans le thread suivant qui acquiert le mutex abandonné.Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. Avant la version 2,0 de la .NET Framework, aucune exception n’a été levée.Before version 2.0 of the .NET Framework, no exception was thrown.

Attention

Un mutex abandonné indique souvent une erreur grave dans le code.An abandoned mutex often indicates a serious error in the code. Lorsqu’un thread se termine sans libérer le mutex, les structures de données protégées par le mutex risquent de ne pas être dans un état cohérent.When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. Le thread suivant pour demander 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.The next thread to request ownership of the mutex can handle this exception and proceed, if the integrity of the data structures can be verified.

Si le mutex est développé au niveau système, et qu’il est abandonné, cela peut indiquer qu’une application a été arrêtée soudainement (par exemple, à l’aide du Gestionnaire des tâches de Windows).In the case of a system-wide mutex, an abandoned mutex might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager).

Les mutex sont de deux types : les mutex locaux, qui sont sans nom et les mutex système nommés.Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. Un mutex local existe uniquement dans votre processus.A local mutex exists only within your process. Il peut être utilisé par tout thread de votre processus qui a une référence à l' Mutex objet qui représente le mutex.It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. Chaque Mutex objet sans nom représente un mutex local distinct.Each unnamed Mutex object represents a separate local mutex.

Les mutex système nommés sont visibles dans tout le système d’exploitation et peuvent être utilisés pour synchroniser les activités des processus.Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. Vous pouvez créer un Mutex objet qui représente un mutex système nommé à l’aide d’un constructeur qui accepte un nom.You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. L’objet de système d’exploitation peut être créé en même temps, ou il peut exister avant la création de l' Mutex objet.The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. Vous pouvez créer plusieurs objets Mutex qui représentent le même mutex de système nommé, et vous pouvez utiliser la méthode OpenExisting pour ouvrir un mutex de système nommé existant.You can create multiple Mutex objects that represent the same named system mutex, and you can use the OpenExisting method to open an existing named system mutex.

Notes

Sur un serveur qui exécute les services Terminal Server, un mutex système nommé peut avoir deux niveaux de visibilité.On a server that is running Terminal Services, a named system mutex can have two levels of visibility. Si son nom commence par le préfixe «\global », le mutex est visible dans toutes les sessions Terminal Server.If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. Si son nom commence par le préfixe «\local », le mutex est visible uniquement dans la session Terminal Server dans laquelle il a été créé.If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. Dans ce cas, un mutex distinct du même nom peut exister dans chacune des autres sessions Terminal Server sur le serveur.In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. Si vous ne spécifiez pas de préfixe lorsque vous créez un mutex nommé, il prend le préfixe « local\».If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". Dans une session Terminal Server, deux mutex dont les noms diffèrent uniquement par leurs préfixes sont des mutex distincts, et les deux sont visibles par tous les processus de la session Terminal Server.Within a terminal server session, two mutexes whose names differ only by their prefixes are separate mutexes, and both are visible to all processes in the terminal server session. Autrement dit, les noms de préfixe\« global » et\« local » décrivent l’étendue du nom de mutex par rapport aux sessions Terminal Server, et non par rapport aux processus.That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

La barre oblique inverse (\) est un caractère réservé dans un nom de mutex.The backslash (\) is a reserved character in a mutex name. N’utilisez pas de barre oblique inverse (\) dans un nom de mutex, sauf si spécifié dans la remarque sur l’utilisation de mutex dans les sessions Terminal Server.Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. Sinon, une DirectoryNotFoundException peut être levée, même si le nom du mutex représente un fichier existant.Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

Constructeurs

Mutex()

Initialise une nouvelle instance de la classe Mutex avec des propriétés par défaut.Initializes a new instance of the Mutex class with default properties.

Mutex(Boolean)

Initialise une nouvelle instance de la classe Mutex avec une valeur Boolean qui indique si le thread appelant doit avoir la propriété initiale du mutex.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex.

Mutex(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.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, and a string that is the name of the mutex.

Mutex(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.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex.

Mutex(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é.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, a Boolean variable that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex, and the access control security to be applied to the named mutex.

Champs

WaitTimeout

Indique que le délai fixé pour une opération WaitAny(WaitHandle[], Int32, Boolean) a été dépassé sans qu'aucun des handles d'attente n'ait été signalé.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Ce champ est constant.This field is constant.

(Hérité de WaitHandle)

Propriétés

Handle

Obtient ou définit le handle du système d'exploitation natif.Gets or sets the native operating system handle.

(Hérité de WaitHandle)
SafeWaitHandle

Obtient ou définit le handle du système d'exploitation natif.Gets or sets the native operating system handle.

(Hérité de WaitHandle)

Méthodes

Close()

Libère toutes les ressources détenues par le WaitHandle actuel.Releases all resources held by the current WaitHandle.

(Hérité de WaitHandle)
CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Hérité de WaitHandle)
Dispose(Boolean)

En cas de substitution dans une classe dérivée, libère les ressources non managées utilisées par WaitHandle et libère éventuellement les ressources managées.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Hérité de WaitHandle)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetAccessControl()

Obtient un objet MutexSecurity qui représente la sécurité de contrôle d'accès pour le mutex nommé.Gets a MutexSecurity object that represents the access control security for the named mutex.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLifetimeService()

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Hérité de MarshalByRefObject)
OpenExisting(String)

Ouvre le mutex nommé spécifié s'il existe déjà.Opens the specified named mutex, if it already exists.

OpenExisting(String, MutexRights)

Ouvre le mutex nommé spécifié, s'il existe déjà, avec l'accès de sécurité souhaité.Opens the specified named mutex, if it already exists, with the desired security access.

ReleaseMutex()

Libère l'objet Mutex une seule fois.Releases the Mutex once.

SetAccessControl(MutexSecurity)

Définit la sécurité de contrôle d'accès pour un mutex système nommé.Sets the access control security for a named system mutex.

ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)
TryOpenExisting(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.Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(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.Opens the specified named mutex, if it already exists, with the desired security access, and returns a value that indicates whether the operation succeeded.

WaitOne()

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal.Blocks the current thread until the current WaitHandle receives a signal.

(Hérité de WaitHandle)
WaitOne(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Hérité de WaitHandle)
WaitOne(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Hérité de WaitHandle)
WaitOne(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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Hérité de WaitHandle)
WaitOne(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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Hérité de WaitHandle)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Libère toutes les ressources utilisées par WaitHandle.Releases all resources used by the WaitHandle.

(Hérité de WaitHandle)

Méthodes d’extension

GetAccessControl(Mutex)
SetAccessControl(Mutex, MutexSecurity)
GetSafeWaitHandle(WaitHandle)

Obtient le handle sécurisé pour un handle d’attente de système d’exploitation natif.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Définit un handle sécurisé pour un handle d’attente de système d’exploitation natif.Sets a safe handle for a native operating system wait handle.

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi