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

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.

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.

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.

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

Felder

Eigenschaften

Methoden

Explizite Schnittstellenimplementierungen

Erweiterungsmethoden

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• WaitHandle
• Thread
• Verwaltetes Threading
• Mutexe