Mutex Mutex Mutex Mutex Class

Definition

Ein primitiver Synchronisierungstyp, der auch für die prozessübergreifende Synchronisierung verwendet werden kann.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
Vererbung
Attribute

Beispiele

Dieses Beispiel zeigt, wie eine lokale Mutex Objekt wird zum Synchronisieren des Zugriffs auf eine geschützte Ressource verwendet.This example shows how a local Mutex object is used to synchronize access to a protected resource. Da jeder aufrufenden Thread blockiert wird, bis er den Besitz des Mutex erhält, muss diese Aufrufen der ReleaseMutex Methode, um den Besitz des Threads freizugeben.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

Im folgenden Beispiel ist jeder Thread Ruft die WaitOne(Int32) Methode, um den Mutex abrufen.In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. Die Methode gibt zurück, wenn das Timeoutintervall abläuft, false, und der Thread das Mutex erhält weder erhält Zugriff auf die Ressource, die der Mutex geschützt.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. Die ReleaseMutex Methode wird aufgerufen, nur von einem Thread, der den Mutex verwendet.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

Hinweise

Wenn zwei oder mehr Threads zur selben Zeit eine freigegebene Ressource zugreifen müssen, benötigt das System einen Synchronisierungsmechanismus, um sicherzustellen, dass jeweils nur ein Thread die Ressource verwendet.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 ist ein Synchronisierungsprimitiver, der exklusiven Zugriff auf die freigegebene Ressource nur ein Thread gewährt.Mutex is a synchronization primitive that grants exclusive access to the shared resource to only one thread. Wenn ein Thread einen Mutex, wird der zweite Thread, der beim Abrufen von dieser Mutex möchte angehalten, bis der erste Thread das Mutex frei.If a thread acquires a mutex, the second thread that wants to acquire that mutex is suspended until the first thread releases the mutex.

Wichtig

Dieser Typ implementiert die IDisposable-Schnittstelle.This type implements the IDisposable interface. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen.When you have finished using the type, you should dispose of it either directly or indirectly. Zum direkten Löschen des Typs rufen Sie seine Dispose-Methode in einem try/catch-Block auf.To dispose of the type directly, call its Dispose method in a try/catch block. Zum indirekten Löschen verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt „Verwenden eines Objekts, das IDisposable implementiert“ des Themas „Die IDisposable-Schnittstelle“.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Sie können die WaitHandle.WaitOne Methode, um den Besitz des Mutex anfordert.You can use the WaitHandle.WaitOne method to request ownership of a mutex. Der aufrufende Thread blockiert, bis eines der folgenden Ereignisse eintritt:The calling thread blocks until one of the following occurs:

  • Mutex wird signalisiert, um anzugeben, dass er nicht gehört.The mutex is signaled to indicate that it is not owned. In diesem Fall die WaitOne Methodenrückgabe true, und der aufrufende Thread übernimmt den Besitz des Mutex und greift auf die vom Mutex geschützte Ressource.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. Wenn sie mit dem Zugriff auf die Ressource abgeschlossen ist, muss der Thread Aufrufen der ReleaseMutex Methode, um den Besitz des Mutex freizugeben.When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. Im erste Beispiel im Abschnitt mit Beispielen veranschaulicht dieses Muster.The first example in the Examples section illustrates this pattern.

  • Das Timeoutintervall, die im Aufruf angegeben ein WaitOne Methode mit einem millisecondsTimeout oder timeout Parameter ist abgelaufen.The time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. In diesem Fall die WaitOne Methodenrückgabe false, und der aufrufende Thread unternimmt keinen weiteren Versuch, den Besitz des Mutex abzurufen.When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. In diesem Fall sollten Sie Ihren Code so strukturieren, dass an den aufrufenden Thread den Zugriff auf die vom Mutex geschützte Ressource verweigert wird.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. Da der Thread nie den Besitz des Mutex erworben haben, müssen sie nicht Aufrufen der ReleaseMutex Methode.Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. Das zweite Beispiel im Abschnitt "Beispiele" veranschaulicht dieses Muster.The second example in the Examples section illustrates this pattern.

Die Mutex Klasse erzwingt die Threadidentität, sodass ein Mutex nur von einem Thread freigegeben werden kann, die sie erworben haben.The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. Im Gegensatz dazu die Semaphore Klasse erzwingen keine Threadidentität.By contrast, the Semaphore class does not enforce thread identity. Ein Mutex kann auch über Anwendungsdomänen hinweg übergeben werden.A mutex can also be passed across application domain boundaries.

Der Thread, der einen Mutex besitzt kann anfordern, dass wiederholte Aufrufe derselben Mutex WaitOne ohne dessen Ausführung zu blockieren.The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. Allerdings muss der Thread Aufrufen der ReleaseMutex Methode die gleiche Anzahl an, wie oft, um den Besitz des Mutex freizugeben.However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

Da die Mutex Klasse erbt von WaitHandle, rufen Sie außerdem die statische WaitHandle.WaitAll und WaitHandle.WaitAny Methoden zum Synchronisieren des Zugriffs auf eine geschützte Ressource.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.

Wenn ein Thread beendet wird, während einen Mutex besitzt, wird der Mutex als abgebrochener Mutex bezeichnet.If a thread terminates while owning a mutex, the mutex is said to be abandoned. Der Status des Mutex wird auf signalisiert festgelegt, und der nächste wartenden Thread Ruft die Inhaberschaft ab.The state of the mutex is set to signaled, and the next waiting thread gets ownership. Ab Version 2.0 von .NET Framework ein AbandonedMutexException wird ausgelöst, in der nächsten Thread, der den abgebrochenen Mutex verwendet.Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. Vor Version 2.0 von .NET Framework wurde keine Ausnahme ausgelöst.Before version 2.0 of the .NET Framework, no exception was thrown.

Achtung

Ein abgebrochenes Mutex weist häufig einen schwerwiegenden Fehler im Code.An abandoned mutex often indicates a serious error in the code. Wenn ein Thread beendet, ohne das Mutex freizugeben, möglicherweise die Datenstrukturen, die vom Mutex geschützte nicht in einem konsistenten Zustand.When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. Der nächste Thread, der Besitz des Mutex anfordert, kann diese Ausnahme behandeln und den Vorgang fortsetzen, wenn die Integrität der Datenstruktur überprüft werden kann.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.

Wenn es sich um einen systemweiten Mutex handelt, kann ein abgebrochener Mutex darauf hinweisen, dass eine Anwendung plötzlich beendet wurde (z.B. über den Windows Task-Manager).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).

Es gibt zwei Typen: Lokale Mutexe, die unbenannte und benannte Systemmutexe.Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. Ein lokaler Mutex ist nur innerhalb des Prozesses vorhanden.A local mutex exists only within your process. Es kann verwendet werden, von jedem Thread im Prozess, die einen Verweis auf die Mutex -Objekt, das den Mutex darstellt.It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. Jeder unbenannte Mutex Objekt darstellt, einen separaten lokalen Mutex.Each unnamed Mutex object represents a separate local mutex.

Benannte Mutexe sind im gesamten Betriebssystem sichtbar und kann zum Synchronisieren der Aktivitäten von Prozessen verwendet werden.Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. Sie erstellen eine Mutex Objekt, das einen benannten Systemmutex darstellt, mithilfe eines Konstruktors, der einen Namen akzeptiert.You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. Das Betriebssystem-Objekt kann zur gleichen Zeit erstellt werden oder es kann vorhanden sein, bevor die Erstellung von der Mutex Objekt.The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. Sie können mehrere Mutex-Objekte erstellen, die denselben benannten Systemmutex darstellen, und Sie können mithilfe der OpenExisting-Methode einen vorhandenen benannten Systemmutex öffnen.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.

Hinweis

Auf einem Server, auf der Terminaldienste ausgeführt wird, haben ein benannten Systemmutex zwei Ebenen der Sichtbarkeit.On a server that is running Terminal Services, a named system mutex can have two levels of visibility. Wenn der Name mit dem Präfix beginnt "Global\", der Mutex ist in allen Sitzungen des Terminalservers sichtbar.If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. Wenn der Name mit dem Präfix beginnt "lokale\", der Mutex ist nur in der Terminalserver-Sitzung sichtbar, in dem es erstellt wurde.If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. In diesem Fall kann ein separater Mutex mit dem gleichen Namen in den einzelnen von den anderen Terminalserver-Sitzungen auf dem Server vorhanden sein.In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. Wenn Sie ein Präfix nicht angeben, wenn Sie einen benannten Mutex erstellen, dauert das Präfix "lokale\".If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". Klicken Sie in einer Terminalserver-Sitzung zwei Mutexe, deren Namen sich nur durch ihre Präfixe unterscheiden, sind separate Mutexe, und beide sind für alle Prozesse sichtbar, in der Terminalserver-Sitzung.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. D. h. den Präfixnamen "Global\" und "lokale\" des Bereichs der Mutex-Namen, relativ zum Sitzungen des Terminalservers, nicht in Bezug auf Prozesse zu beschreiben.That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

Der umgekehrte Schrägstrich \ stellt in Mutex-Namen ein reserviertes Zeichen dar.The backslash (\) is a reserved character in a mutex name. Verwenden Sie umgekehrte Schrägstriche (\) in Mutex-Namen nur wie in dem Hinweis zur Verwendung von Mutex-Objekten in Sitzungen des Terminalservers beschrieben.Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. Andernfalls kann sogar eine DirectoryNotFoundException ausgelöst werden, wenn der Mutex-Name für eine bereits vorhandene Datei steht.Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

Konstruktoren

Mutex() Mutex() Mutex() Mutex()

Initialisiert eine neue Instanz der Mutex-Klasse mit Standardeigenschaften.Initializes a new instance of the Mutex class with default properties.

Mutex(Boolean) Mutex(Boolean) Mutex(Boolean) Mutex(Boolean)

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll.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) Mutex(Boolean, String) Mutex(Boolean, String) Mutex(Boolean, String)

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, sowie mit einer Zeichenfolge, die den Namen des Mutex darstellt.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) Mutex(Boolean, String, Boolean) Mutex(Boolean, String, Boolean) Mutex(Boolean, String, Boolean)

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, mit einer Zeichenfolge mit dem Namen des Mutex sowie mit einem booleschen Wert, der beim Beenden der Methode angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex gewährt wurde.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) Mutex(Boolean, String, Boolean, MutexSecurity) Mutex(Boolean, String, Boolean, MutexSecurity) Mutex(Boolean, String, Boolean, MutexSecurity)

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, mit einer Zeichenfolge mit dem Namen des Mutex, mit einer booleschen Variable, die beim Beenden der Methode angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex gewährt wurde, und mit der Zugriffssteuerungssicherheit, die auf den benannten Mutex angewendet werden soll.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.

Methoden

Close() Close() Close() Close()

Gibt alle von der aktuellen WaitHandle-Klasse reservierten Ressourcen frei.Releases all resources held by the current WaitHandle.

(Inherited from WaitHandle)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei.Releases all resources used by the current instance of the WaitHandle class.

(Inherited from WaitHandle)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Gibt beim Überschreiben in einer abgeleiteten Klasse die von WaitHandle verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Inherited from WaitHandle)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAccessControl() GetAccessControl() GetAccessControl() GetAccessControl()

Ruft ein MutexSecurity-Objekt ab, das die Zugriffssteuerungssicherheit für den benannten Mutex darstellt.Gets a MutexSecurity object that represents the access control security for the named mutex.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
OpenExisting(String) OpenExisting(String) OpenExisting(String) OpenExisting(String)

Öffnet den bestimmten benannten Mutex, wenn er bereits vorhanden ist.Opens the specified named mutex, if it already exists.

OpenExisting(String, MutexRights) OpenExisting(String, MutexRights) OpenExisting(String, MutexRights) OpenExisting(String, MutexRights)

Öffnet den angegebenen benannten Mutex, wenn er bereits vorhanden ist, mit dem gewünschten Sicherheitszugriff.Opens the specified named mutex, if it already exists, with the desired security access.

ReleaseMutex() ReleaseMutex() ReleaseMutex() ReleaseMutex()

Gibt das Mutex einmal frei.Releases the Mutex once.

SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity)

Legt die Zugriffssteuerungssicherheit für einen benannten Systemmutex fest.Sets the access control security for a named system mutex.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)
TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex)

Öffnet den bestimmten benannten Mutex, wenn er bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, MutexRights, Mutex) TryOpenExisting(String, MutexRights, Mutex) TryOpenExisting(String, MutexRights, Mutex) TryOpenExisting(String, MutexRights, Mutex)

Öffnet den angegebenen benannten Mutex, wenn er bereits mit dem gewünschten Sicherheitszugriff vorhanden ist und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.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() WaitOne() WaitOne() WaitOne()

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.Blocks the current thread until the current WaitHandle receives a signal.

(Inherited from WaitHandle)
WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) WaitOne(Int32)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls in Millisekunden verwendet wird.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Inherited from WaitHandle)
WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.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.

(Inherited from WaitHandle)
WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Inherited from WaitHandle)
WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.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.

(Inherited from WaitHandle)

Eigenschaften

Handle Handle Handle Handle

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.Gets or sets the native operating system handle.

(Inherited from WaitHandle)
SafeWaitHandle SafeWaitHandle SafeWaitHandle SafeWaitHandle

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.Gets or sets the native operating system handle.

(Inherited from WaitHandle)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Gibt alle vom WaitHandle verwendeten Ressourcen frei.Releases all resources used by the WaitHandle.

(Inherited from WaitHandle)

Felder

WaitTimeout WaitTimeout WaitTimeout WaitTimeout

Gibt an, dass ein Timeout für einen WaitAny(WaitHandle[], Int32, Boolean)-Vorgang überschritten wurde, bevor ein Signal an eines der WaitHandles gesendet wurde.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Dieses Feld ist konstant.This field is constant.

(Inherited from WaitHandle)

Extension Methods

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

Ruft das sichere Handle für ein systemeigenes Betriebssystem-Wait-Handle ab.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Stellt ein sicheres Handle für ein systemeigenes Betriebssystem-Wait-Handle ein.Sets a safe handle for a native operating system wait handle.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.This type is thread safe.

Siehe auch