Mutex Klasse

Definition

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

Object

WaitHandle

Mutex

Vererbung

Object

MarshalByRefObject

WaitHandle

Mutex

Attribute

ComVisibleAttribute

Beispiele

Dieses Beispiel zeigt, 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 er die ReleaseMutex Methode aufrufen, um den 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 erhält weder den Mutex noch erhält Zugriff auf die Ressource, die der Mutex schützt. Die ReleaseMutex Methode wird nur vom Thread aufgerufen, der den Mutex erhält.

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 gleichzeitig auf eine freigegebene Ressource zugreifen müssen, benötigt das System einen Synchronisierungsmechanismus, um sicherzustellen, dass nur jeweils ein Thread die Ressource verwendet. Mutex ist ein Synchronisierungsgrundtyp, der exklusiven Zugriff auf die freigegebene Ressource nur für einen Thread 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 loslässt.

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

• Der Mutex wird signalisiert, um anzugeben, dass es 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 durch den Mutex geschützte Ressource zu. Wenn der Zugriff auf die Ressource abgeschlossen ist, muss der Thread die ReleaseMutex Methode aufrufen, um den Besitz des Mutex freizugeben. Das erste Beispiel im Abschnitt "Beispiele" veranschaulicht dieses Muster.

• Das timeout-Intervall, das im Aufruf einer WaitOne Methode angegeben ist, deren millisecondsTimeout Parameter timeout abgelaufen ist. 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 den Code so strukturieren, dass der Zugriff auf die Ressource, die durch den Mutex geschützt ist, dem aufrufenden Thread verweigert wird. 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 vom 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 ein Mutex besitzt, kann den gleichen Mutex in wiederholten Aufrufen WaitOne anfordern, ohne die Ausführung zu blockieren. Der Thread muss die Methode jedoch mehrmals aufrufen, um den Besitz des Mutex freizugeben ReleaseMutex .

Da die Mutex Klasse erbt, WaitHandlekönnen Sie auch die statischen WaitHandle.WaitAll Methoden WaitHandle.WaitAny aufrufen, um den Zugriff auf eine geschützte Ressource zu synchronisieren.

Wenn ein Thread beendet wird, während er einen Mutex besitzt, wird der Mutex als abgebrochen bezeichnet. Der Status des Mutex wird signalisiert, und der nächste Wartethread erhält den Besitz. Ab Version 2.0 des .NET Frameworks wird ein AbandonedMutexException im nächsten Thread ausgelöst, der den abgebrochenen Mutex erhält. Vor Version 2.0 des .NET Frameworks wurde keine Ausnahme ausgelöst.

Bei einem systemweiten Mutex kann ein verlassener Mutex darauf hinweisen, dass eine Anwendung abrupt beendet wurde (z. B. mithilfe des Windows-Task-Managers).

Mutexes sind von zwei Typen: lokale Mutexe, die unbenannt sind, und benannte Systemmutexes. Ein lokaler Mutex ist nur innerhalb des Prozesses vorhanden. Sie kann von einem beliebigen 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 Systemmutexes 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 die OpenExisting Methode verwenden, um einen vorhandenen benannten Systemmutex zu öffnen.

Der umgekehrte Schrägstrich (\) ist ein reserviertes Zeichen in einem Mutex-Namen. Verwenden Sie keinen umgekehrten Schrägstrich (\) in einem Mutex-Namen, außer in der Notiz zur Verwendung von Mutexen in Terminalserversitzungen angegeben. Andernfalls kann ein DirectoryNotFoundException Fehler ausgelöst werden, obwohl der Name des Mutex eine vorhandene Datei darstellt.

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• WaitHandle
• Thread
• Verwaltetes Thread-Management
• Mutexe