Mutex Klasse

Definition

Ein primitiver Synchronisierungstyp, der auch für die prozessübergreifende Synchronisierung verwendet werden kann.

public ref class Mutex sealed : System::Threading::WaitHandle
public sealed class Mutex : System.Threading.WaitHandle
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Mutex : System.Threading.WaitHandle
type Mutex = class
    inherit WaitHandle
[<System.Runtime.InteropServices.ComVisible(true)>]
type Mutex = class
    inherit WaitHandle
Public NotInheritable Class Mutex
Inherits WaitHandle
Vererbung
Vererbung
Attribute

Beispiele

In diesem Beispiel wird gezeigt, wie ein lokales Mutex Objekt verwendet wird, um den Zugriff auf eine geschützte Ressource zu synchronisieren. Da jeder aufrufende Thread blockiert wird, bis er den Besitz des Mutex erhält, muss die Methode aufgerufen werden, um den ReleaseMutex Besitz des Mutex freizugeben.

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 ruft jeder Thread die WaitOne(Int32) -Methode auf, um den Mutex zu erhalten. Wenn das Timeoutintervall verstrichen ist, gibt die Methode zurück false, und der Thread ruft weder den Mutex ab, noch erhält er Zugriff auf die Ressource, die der Mutex schützt. Die ReleaseMutex -Methode wird nur von dem Thread aufgerufen, der den Mutex abruft.

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 mindestens zwei Threads gleichzeitig auf eine freigegebene Ressource zugreifen müssen, benötigt das System einen Synchronisierungsmechanismus, um sicherzustellen, dass nur ein Thread gleichzeitig die Ressource verwendet. Mutex ist ein Synchronisierungsgrundtyp, der nur einem Thread exklusiven Zugriff auf die freigegebene Ressource gewährt. Wenn ein Thread einen Mutex erhält, wird der zweite Thread, der diesen Mutex abrufen möchte, angehalten, bis der erste Thread den Mutex freigibt.

Wichtig

Dieser Typ implementiert die IDisposable-Schnittstelle. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen. Zum direkten Löschen des Typs rufen Sie seine Dispose-Methode in einem try/catch-Block auf. Zum indirekten Löschen verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt „Verwenden eines Objekts, das IDisposable implementiert“ des Themas „Die IDisposable-Schnittstelle“.

Sie können die WaitHandle.WaitOne -Methode verwenden, um den Besitz eines Mutex anzufordern. Der aufrufende Thread blockiert, bis einer der folgenden Aktionen auftritt:

  • Dem Mutex wird signalisiert, dass er nicht im Besitz ist. In diesem Fall gibt die WaitOne Methode zurück true, und der aufrufende Thread übernimmt den Besitz des Mutex und greift auf die ressource zu, die durch den Mutex geschützt wird. Wenn der Zugriff auf die Ressource abgeschlossen ist, muss der Thread die -Methode aufrufen, um den ReleaseMutex Besitz des Mutex freizugeben. Das erste Beispiel im Abschnitt Beispiele veranschaulicht dieses Muster.

  • Das timeoutintervall, das im Aufruf einer WaitOne Methode angegeben wird, die über einen millisecondsTimeout Oder-Parameter timeout verfügt, ist verstrichen. In diesem Fall gibt die WaitOne Methode zurück false, und der aufrufende Thread versucht nicht mehr, den Besitz des Mutex zu erwerben. In diesem Fall sollten Sie Ihren Code so strukturieren, dass dem aufrufenden Thread der Zugriff auf die ressource verweigert wird, die durch den Mutex geschützt ist. Da der Thread nie den Besitz des Mutex erworben hat, darf er die ReleaseMutex -Methode nicht aufrufen. Das zweite Beispiel im Abschnitt Beispiele veranschaulicht dieses Muster.

Die Mutex -Klasse erzwingt die Threadidentität, sodass ein Mutex nur von dem Thread freigegeben werden kann, der ihn erworben hat. Im Gegensatz dazu erzwingt die Semaphore Klasse keine Threadidentität. Ein Mutex kann auch über Anwendungsdomänengrenzen hinweg übergeben werden.

Der Thread, der einen Mutex besitzt, kann denselben Mutex in wiederholten Aufrufen anfordern, ohne dessen Ausführung zu WaitOne blockieren. Der Thread muss die ReleaseMutex Methode jedoch genauso oft aufrufen, um den Besitz des Mutex freizugeben.

Da die Mutex -Klasse von WaitHandleerbt, können Sie auch die statischen WaitHandle.WaitAll Methoden und WaitHandle.WaitAny aufrufen, um den Zugriff auf eine geschützte Ressource zu synchronisieren.

Wenn ein Thread beendet wird, während er einen Mutex besitzt, gilt der Mutex als verlassen. Der Status des Mutex wird auf signalisiert festgelegt, und der nächste wartende Thread erhält Besitz. Ab Version 2.0 der .NET Framework wird im nächsten Thread ein AbandonedMutexException ausgelöst, der den verlassenen Mutex abruft. Vor Version 2.0 des .NET Framework wurde keine Ausnahme ausgelöst.

Achtung

Ein verlassener Mutex weist häufig auf einen schwerwiegenden Fehler im Code hin. Wenn ein Thread beendet wird, ohne den Mutex loszulassen, befinden sich die durch den Mutex geschützten Datenstrukturen möglicherweise nicht in einem konsistenten Zustand. Der nächste Thread, um den Besitz des Mutex anzufordern, kann diese Ausnahme behandeln und fortfahren, wenn die Integrität der Datenstrukturen überprüft werden kann.

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).

Mutexes sind zwei Typen: lokale Mutexe, die nicht benannt sind, und benannte Systemmutexe. Ein lokaler Mutex ist nur innerhalb des Prozesses vorhanden. Sie kann von jedem Thread in Ihrem Prozess verwendet werden, der einen Verweis auf das Mutex Objekt enthält, das den Mutex darstellt. Jedes unbenannte Mutex Objekt stellt einen separaten lokalen Mutex dar.

Benannte Systemmutexe sind im gesamten Betriebssystem sichtbar und können verwendet werden, um die Aktivitäten von Prozessen zu synchronisieren. Sie können ein Mutex Objekt erstellen, das einen benannten Systemmutex darstellt, indem Sie einen Konstruktor verwenden, der einen Namen akzeptiert. Das Betriebssystemobjekt kann gleichzeitig erstellt werden, oder es kann vor der Erstellung des Mutex Objekts vorhanden sein. 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.

Hinweis

Auf einem Server, auf dem Terminaldienste ausgeführt werden, kann ein benannter Systemmutex zwei Sichtbarkeitsebenen aufweisen. Wenn sein Name mit dem Präfix Global\beginnt, ist der Mutex in allen Terminalserversitzungen sichtbar. Wenn sein Name mit dem Präfix Local\beginnt, ist der Mutex nur in der Terminalserversitzung sichtbar, in der er erstellt wurde. In diesem Fall kann in jeder der anderen Terminalserversitzungen auf dem Server ein separater Mutex mit demselben Namen vorhanden sein. Wenn Sie beim Erstellen eines benannten Mutex kein Präfix angeben, wird das Präfix Local\verwendet. Innerhalb einer Terminalserversitzung sind zwei Mutexe, deren Namen sich nur durch ihre Präfixe unterscheiden, separate Mutexe, und beide sind für alle Prozesse in der Terminalserversitzung sichtbar. Das heißt, die Präfixnamen Global\ und Local\ beschreiben den Bereich des Mutexnamens relativ zu Terminalserversitzungen, nicht relativ zu Prozessen.

Achtung

Standardmäßig ist ein benannter Mutex nicht auf den Benutzer beschränkt, der ihn erstellt hat. Andere Benutzer sind möglicherweise in der Lage, den Mutex zu öffnen und zu verwenden, einschließlich der Störung des Mutex, indem sie den Mutex eingeben und ihn nicht verlassen. Unter Unix-ähnlichen Betriebssystemen wird das Dateisystem bei der Implementierung von benannten Mutexes verwendet, und andere Benutzer können in der Lage sein, benannte Mutexe auf wichtigere Weise zu beeinträchtigen. Um den Zugriff auf bestimmte Benutzer unter Windows einzuschränken, können Sie eine Konstruktorüberladung oder MutexAcl verwenden und beim Erstellen des benannten Mutex übergeben MutexSecurity . Unter Unix-ähnlichen Betriebssystemen gibt es derzeit keine Möglichkeit, den Zugriff auf einen benannten Mutex einzuschränken. Vermeiden Sie die Verwendung benannter Mutexes ohne Zugriffsbeschränkungen auf Systemen, auf denen möglicherweise nicht vertrauenswürdige Benutzer Code ausführen.

Der umgekehrte Schrägstrich (\) ist ein reserviertes Zeichen in einem Mutexnamen. Verwenden Sie keinen umgekehrten Schrägstrich (\) in einem Mutex-Namen, es sei denn, dies ist im Hinweis zur Verwendung von Mutexes in Terminalserversitzungen angegeben. Andernfalls kann sogar eine DirectoryNotFoundException ausgelöst werden, wenn der Mutex-Name für eine bereits vorhandene Datei steht.

Konstruktoren

Mutex()

Initialisiert eine neue Instanz der Mutex-Klasse mit Standardeigenschaften.

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.

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.

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.

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.

Felder

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. Dieses Feld ist konstant.

(Geerbt von WaitHandle)

Eigenschaften

Handle
Veraltet.
Veraltet.

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.

(Geerbt von WaitHandle)
SafeWaitHandle

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.

(Geerbt von WaitHandle)

Methoden

Close()

Gibt alle von der aktuellen WaitHandle-Klasse reservierten Ressourcen frei.

(Geerbt von WaitHandle)
CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.

(Geerbt von MarshalByRefObject)
Dispose()

Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei.

(Geerbt von WaitHandle)
Dispose(Boolean)

Gibt beim Überschreiben in einer abgeleiteten Klasse die von WaitHandle verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

(Geerbt von WaitHandle)
Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetAccessControl()

Ruft ein MutexSecurity-Objekt ab, das die Zugriffssteuerungssicherheit für den benannten Mutex darstellt.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetLifetimeService()
Veraltet.

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.

(Geerbt von MarshalByRefObject)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
InitializeLifetimeService()
Veraltet.

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.

(Geerbt von MarshalByRefObject)
OpenExisting(String)

Öffnet den bestimmten benannten Mutex, wenn er bereits vorhanden ist.

OpenExisting(String, MutexRights)

Öffnet den angegebenen benannten Mutex, wenn er bereits vorhanden ist, mit dem gewünschten Sicherheitszugriff.

ReleaseMutex()

Gibt das Mutex einmal frei.

SetAccessControl(MutexSecurity)

Legt die Zugriffssteuerungssicherheit für einen benannten Systemmutex fest.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
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.

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.

WaitOne()

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.

(Geerbt von WaitHandle)
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.

(Geerbt von WaitHandle)
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.

(Geerbt von WaitHandle)
WaitOne(TimeSpan)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird.

(Geerbt von WaitHandle)
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.

(Geerbt von WaitHandle)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Diese API unterstützt die Produktinfrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code gedacht.

Gibt alle vom WaitHandle verwendeten Ressourcen frei.

(Geerbt von WaitHandle)

Erweiterungsmethoden

GetAccessControl(Mutex)

Gibt die Sicherheitsbeschreibungen für den angegebenen mutex zurück.

SetAccessControl(Mutex, MutexSecurity)

Legt die Sicherheitsbeschreibungen für den angegebenen Mutex fest.

GetSafeWaitHandle(WaitHandle)

Ruft das sichere Handle für ein systemeigenes Betriebssystem-Wait-Handle ab.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Stellt ein sicheres Handle für ein systemeigenes Betriebssystem-Wait-Handle ein.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen