Mutex Classe

Definizione

Primitiva di sincronizzazione che può essere utilizzata anche per la sincronizzazione interprocesso.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
Ereditarietà
Attributi

Esempi

Questo esempio Mostra come viene usato Mutex un oggetto locale per sincronizzare l'accesso a una risorsa protetta.This example shows how a local Mutex object is used to synchronize access to a protected resource. Poiché ogni thread chiamante viene bloccato fino a quando non acquisisce la proprietà del mutex, deve chiamare ReleaseMutex il metodo per rilasciare la proprietà del 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

Nell'esempio seguente ogni thread chiama il WaitOne(Int32) metodo per acquisire il mutex.In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. Se l'intervallo di timeout scade, il metodo restituisce falsee il thread non acquisisce il mutex né ottiene l'accesso alla risorsa protetta dal 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. Il ReleaseMutex metodo viene chiamato solo dal thread che acquisisce il 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

Commenti

Quando due o più thread devono accedere a una risorsa condivisa allo stesso tempo, il sistema richiede un meccanismo di sincronizzazione per garantire che solo un thread alla volta usi la risorsa.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. Mutexè una primitiva di sincronizzazione che concede l'accesso esclusivo alla risorsa condivisa a un solo thread.Mutex is a synchronization primitive that grants exclusive access to the shared resource to only one thread. Se un thread acquisisce un mutex, il secondo thread che desidera acquisire tale mutex viene sospeso fino a quando il primo thread non rilascia il 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.

Importante

Il tipo implementa l'interfaccia IDisposable.This type implements the IDisposable interface. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente.When you have finished using the type, you should dispose of it either directly or indirectly. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic.To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

È possibile utilizzare il WaitHandle.WaitOne metodo per richiedere la proprietà di un mutex.You can use the WaitHandle.WaitOne method to request ownership of a mutex. Il thread chiamante si blocca fino a quando non si verifica una delle condizioni seguenti:The calling thread blocks until one of the following occurs:

  • Il mutex viene segnalato per indicare che non è di proprietà.The mutex is signaled to indicate that it is not owned. Quando ciò si verifica, WaitOne il metodo truerestituisce e il thread chiamante presuppone la proprietà del mutex e accede alla risorsa protetta dal 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. Al termine dell'accesso alla risorsa, il thread deve chiamare il ReleaseMutex metodo per rilasciare la proprietà del mutex.When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. Questo modello è illustrato nel primo esempio della sezione esempi.The first example in the Examples section illustrates this pattern.

  • È trascorso l'intervallo di timeout specificato nella chiamata a un WaitOne metodo con un millisecondsTimeout parametro o timeout .The time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. Quando ciò si verifica, WaitOne il metodo falserestituisce e il thread chiamante non tenta di acquisire la proprietà del mutex.When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. In questo caso, è necessario strutturare il codice in modo che l'accesso alla risorsa protetta dal mutex venga negato al thread chiamante.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. Poiché il thread non ha mai acquisito la proprietà del mutex, non deve chiamare ReleaseMutex il metodo.Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. Questo modello è illustrato nel secondo esempio della sezione esempi.The second example in the Examples section illustrates this pattern.

La Mutex classe impone l'identità del thread, quindi un mutex può essere rilasciato solo dal thread che lo ha acquisito.The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. Al contrario, la Semaphore classe non impone l'identità del thread.By contrast, the Semaphore class does not enforce thread identity. Un mutex può essere passato anche attraverso i limiti del dominio applicazione.A mutex can also be passed across application domain boundaries.

Il thread proprietario di un mutex può richiedere lo stesso mutex nelle chiamate ripetute WaitOne a senza bloccarne l'esecuzione.The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. Tuttavia, il thread deve chiamare il ReleaseMutex metodo lo stesso numero di volte per rilasciare la proprietà del mutex.However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

Poiché la Mutex classe eredita da WaitHandle, è anche possibile chiamare i metodi WaitHandle.WaitAll statici WaitHandle.WaitAny e per sincronizzare l'accesso a una risorsa protetta.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.

Se un thread termina mentre possiede un mutex, il mutex viene detto abbandonato.If a thread terminates while owning a mutex, the mutex is said to be abandoned. Lo stato del mutex è impostato su segnalato e il thread in attesa successivo ottiene la proprietà.The state of the mutex is set to signaled, and the next waiting thread gets ownership. A partire dalla versione 2,0 della .NET Framework, viene AbandonedMutexException generata un'eccezione nel thread successivo che acquisisce il mutex abbandonato.Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. Prima della versione 2,0 della .NET Framework, non è stata generata alcuna eccezione.Before version 2.0 of the .NET Framework, no exception was thrown.

Attenzione

Un mutex abbandonato spesso indica un errore grave nel codice.An abandoned mutex often indicates a serious error in the code. Quando un thread esce senza rilasciare il mutex, è possibile che le strutture di dati protette dal mutex non si trovino in uno stato coerente.When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. Il thread successivo per richiedere la proprietà del mutex può gestire questa eccezione e continuare se è possibile verificare l'integrità delle strutture di dati.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.

Nel caso di un mutex di sistema, un mutex abbandonato potrebbe indicare che un'applicazione è stata terminata in modo anomalo (ad esempio, usando Gestione attività 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).

I mutex sono di due tipi: mutex locali, senza nome e mutex di sistema denominati.Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. Un mutex locale esiste solo all'interno del processo.A local mutex exists only within your process. Può essere usato da qualsiasi thread nel processo che ha un riferimento all' Mutex oggetto che rappresenta il mutex.It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. Ogni Mutex oggetto senza nome rappresenta un mutex locale separato.Each unnamed Mutex object represents a separate local mutex.

I mutex di sistema denominati sono visibili in tutto il sistema operativo e possono essere usati per sincronizzare le attività dei processi.Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. È possibile creare un Mutex oggetto che rappresenta un mutex di sistema denominato usando un costruttore che accetta un nome.You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. L'oggetto del sistema operativo può essere creato allo stesso tempo oppure può esistere prima della creazione dell' Mutex oggetto.The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. È possibile creare più oggetti Mutex che rappresentano lo stesso mutex di sistema denominato ed è possibile usare il metodo OpenExisting per aprire un mutex di sistema denominato esistente.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.

Nota

In un server che esegue Servizi terminal, un mutex di sistema denominato può avere due livelli di visibilità.On a server that is running Terminal Services, a named system mutex can have two levels of visibility. Se il nome inizia con il prefisso "globale\", il mutex è visibile in tutte le sessioni di Terminal Server.If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. Se il nome inizia con il prefisso "Local\", il mutex è visibile solo nella sessione di Terminal Server in cui è stato creato.If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. In tal caso, è possibile che esista un mutex separato con lo stesso nome in ogni altra sessione di Terminal Server sul server.In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. Se non si specifica un prefisso quando si crea un mutex denominato, prende il prefisso "Local\".If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". All'interno di una sessione di Terminal Server, due mutex i cui nomi differiscono solo per i rispettivi prefissi sono mutex distinti ed entrambi sono visibili a tutti i processi nella sessione 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. Ovvero i nomi di prefisso "Global\" e "Local\" descrivono l'ambito del nome mutex rispetto alle sessioni di Terminal Server, non rispetto ai processi.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 barra rovesciata (\) è un carattere riservato in un nome di mutex.The backslash (\) is a reserved character in a mutex name. Non usare una barra rovesciata (\) in un nome del mutex, se non come specificato nella nota sull'uso dei mutex nelle sessioni di Terminal Server.Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. In caso contrario, potrebbe essere generata una DirectoryNotFoundException, anche se il nome del mutex rappresenta un file esistente.Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

Costruttori

Mutex()

Inizializza una nuova istanza della classe Mutex con le proprietà predefinite.Initializes a new instance of the Mutex class with default properties.

Mutex(Boolean)

Inizializza una nuova istanza della classe Mutex con un valore Boolean che indica se il thread chiamante deve avere la proprietà iniziale del 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)

Inizializza una nuova istanza della classe Mutex con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex e con una stringa che rappresenta il nome del 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)

Inizializza una nuova istanza della classe Mutex con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex, con una stringa che rappresenta il nome del mutex e con un valore booleano che, quando il metodo viene restituito, indichi se al thread chiamante era stata concessa la proprietà iniziale del 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, 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)

Inizializza una nuova istanza della classe Mutex con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex, con una stringa che rappresenta il nome del mutex, con una variabile Boolean che, quando il metodo viene restituito, indichi se al thread chiamante era stata concessa la proprietà iniziale del mutex e con la sicurezza del controllo di accesso da applicare al mutex denominato.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.

Campi

WaitTimeout

Indica che si è verificato il timeout di un'operazione WaitAny(WaitHandle[], Int32, Boolean) prima della segnalazione di uno degli handle di attesa.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Questo campo è costante.This field is constant.

(Ereditato da WaitHandle)

Proprietà

Handle

Ottiene o imposta l'handle nativo del sistema operativo.Gets or sets the native operating system handle.

(Ereditato da WaitHandle)
SafeWaitHandle

Ottiene o imposta l'handle nativo del sistema operativo.Gets or sets the native operating system handle.

(Ereditato da WaitHandle)

Metodi

Close()

Rilascia tutte le risorse contenute nell'oggetto WaitHandle corrente.Releases all resources held by the current WaitHandle.

(Ereditato da WaitHandle)
CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Ereditato da MarshalByRefObject)
Dispose()

Rilascia tutte le risorse usate dall'istanza corrente della classe WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Ereditato da WaitHandle)
Dispose(Boolean)

Quando ne viene eseguito l'override in una classe derivata, libera le risorse non gestite usate da WaitHandle ed eventualmente di liberare le risorse gestite.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Ereditato da WaitHandle)
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetAccessControl()

Ottiene un oggetto MutexSecurity che rappresenta la sicurezza del controllo di accesso per il mutex denominato.Gets a MutexSecurity object that represents the access control security for the named mutex.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Ereditato da MarshalByRefObject)
OpenExisting(String)

Apre il mutex denominato specificato, se esistente.Opens the specified named mutex, if it already exists.

OpenExisting(String, MutexRights)

Apre il mutex denominato specificato, se esistente, con l'accesso di sicurezza desiderato.Opens the specified named mutex, if it already exists, with the desired security access.

ReleaseMutex()

Rilascia l'oggetto Mutex una volta.Releases the Mutex once.

SetAccessControl(MutexSecurity)

Imposta la sicurezza del controllo di accesso per un mutex di sistema denominato.Sets the access control security for a named system mutex.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
TryOpenExisting(String, Mutex)

Apre il mutex denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è stata completata.Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, MutexRights, Mutex)

Apre il mutex denominato specificato, se esistente, con l'accesso di sicurezza desiderato, e restituisce un valore che indica se l'operazione è stata completata.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()

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale.Blocks the current thread until the current WaitHandle receives a signal.

(Ereditato da WaitHandle)
WaitOne(Int32)

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Ereditato da WaitHandle)
WaitOne(Int32, Boolean)

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.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.

(Ereditato da WaitHandle)
WaitOne(TimeSpan)

Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Ereditato da WaitHandle)
WaitOne(TimeSpan, Boolean)

Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un oggetto TimeSpan per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.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.

(Ereditato da WaitHandle)

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Rilascia tutte le risorse usate da WaitHandle.Releases all resources used by the WaitHandle.

(Ereditato da WaitHandle)

Metodi di estensione

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

Ottiene l'handle sicuro per un handle di attesa nativo del sistema operativo.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Imposta un handle sicuro per un handle di attesa nativo del sistema operativo.Sets a safe handle for a native operating system wait handle.

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche