Mutex Klas

Definitie

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

Overname

Object

WaitHandle

Mutex

Overname

Object

MarshalByRefObject

WaitHandle

Mutex

Kenmerken

ComVisibleAttribute

Voorbeelden

In dit voorbeeld ziet u hoe een lokaal Mutex object wordt gebruikt om de toegang tot een beveiligde resource te synchroniseren. Omdat elke aanroepende thread wordt geblokkeerd totdat deze eigenaar wordt van de mutex, moet deze de methode aanroepen om het ReleaseMutex eigendom van de mutex vrij te geven.

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

In het volgende voorbeeld roept elke thread de WaitOne(Int32) methode aan om de mutex te verkrijgen. Als het time-outinterval is verstreken, retourneert falsede methode en verkrijgt de thread de mutex niet en krijgt de mutex geen toegang tot de resource die de mutex beveiligt. De ReleaseMutex methode wordt alleen aangeroepen door de thread die de mutex verkrijgt.

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

Opmerkingen

Wanneer twee of meer threads tegelijkertijd toegang nodig hebben tot een gedeelde resource, heeft het systeem een synchronisatiemechanisme nodig om ervoor te zorgen dat slechts één thread tegelijk de resource gebruikt. Mutex is een synchronisatieprimitief dat exclusieve toegang tot de gedeelde resource verleent aan slechts één thread. Als een thread een mutex verkrijgt, wordt de tweede thread die die mutex wil verkrijgen, onderbroken totdat de eerste thread de mutex vrijgeeft.

U kunt de WaitHandle.WaitOne methode gebruiken om het eigendom van een mutex aan te vragen. De aanroepende thread blokkeert totdat een van de volgende handelingen plaatsvindt:

• De mutex wordt gesignaleerd om aan te geven dat deze niet eigendom is. Wanneer dit gebeurt, retourneert WaitOnede true methode en gaat de aanroepende thread ervan uit dat de mutex eigendom is en dat de resource wordt geopend die wordt beveiligd door de mutex. Wanneer de resource is geopend, moet de thread de ReleaseMutex methode aanroepen om het eigendom van de mutex vrij te geven. In het eerste voorbeeld in de sectie Voorbeelden ziet u dit patroon.

• Het time-outinterval dat is opgegeven in de aanroep naar een WaitOne methode waarvoor een millisecondsTimeout of timeout parameter is verstreken. Wanneer dit gebeurt, retourneert WaitOnede false methode en probeert de aanroepende thread geen eigendom van de mutex te verkrijgen. In dit geval moet u uw code structuren zodat toegang tot de resource die wordt beveiligd door de mutex, wordt geweigerd aan de aanroepende thread. Omdat de thread nooit het eigendom van de mutex heeft verkregen, mag deze de ReleaseMutex methode niet aanroepen. In het tweede voorbeeld in de sectie Voorbeelden ziet u dit patroon.

De Mutex klasse dwingt threadidentiteit af, zodat een mutex alleen kan worden vrijgegeven door de thread die deze heeft verkregen. De klasse dwingt daarentegen Semaphore geen threadidentiteit af. Een mutex kan ook worden doorgegeven aan de grenzen van het toepassingsdomein.

De thread die eigenaar is van een mutex kan dezelfde mutex aanvragen in herhaalde aanroepen WaitOne zonder de uitvoering ervan te blokkeren. De thread moet echter hetzelfde aantal keren de ReleaseMutex methode aanroepen om het eigendom van de mutex vrij te geven.

Omdat de Mutex klasse wordt overgenomen van WaitHandle, kunt u ook de statische WaitHandle.WaitAll en WaitHandle.WaitAny methoden aanroepen om de toegang tot een beveiligde resource te synchroniseren.

Als een thread wordt beëindigd tijdens het bezit van een mutex, wordt gezegd dat de mutex wordt afgebroken. De status van de mutex is ingesteld op gesignaleerd en de volgende wachtthread krijgt eigendom. Vanaf versie 2.0 van het .NET Framework wordt er een AbandonedMutexException gegenereerd in de volgende thread waarmee de verlaten mutex wordt verkregen. Vóór versie 2.0 van het .NET Framework is er geen uitzondering opgetreden.

In het geval van een systeem-brede mutex kan een achtergelaten mutex erop wijzen dat een toepassing plotseling is beëindigd (bijvoorbeeld met behulp van Windows Taakbeheer).

Mutexes zijn van twee typen: lokale mutexes, die geen naam hebben, en benoemde systeemmutexes. Een lokale mutex bestaat alleen binnen uw proces. Het kan worden gebruikt door elke thread in uw proces met een verwijzing naar het Mutex object dat de mutex vertegenwoordigt. Elk niet-benoemd Mutex object vertegenwoordigt een afzonderlijke lokale mutex.

Benoemde systeemmutexes zijn zichtbaar in het hele besturingssysteem en kunnen worden gebruikt om de activiteiten van processen te synchroniseren. U kunt een Mutex object maken dat een benoemde systeemmutex vertegenwoordigt met behulp van een constructor die een naam accepteert. Het besturingssysteemobject kan tegelijkertijd worden gemaakt of kan bestaan voordat het Mutex object wordt gemaakt. U kunt meerdere Mutex objecten maken die dezelfde benoemde systeemmutex vertegenwoordigen en u kunt de OpenExisting methode gebruiken om een bestaande benoemde systeemmutex te openen.

De backslash (\) is een gereserveerd teken in een mutex-naam. Gebruik geen backslash (\) in een mutex-naam, behalve zoals opgegeven in de opmerking over het gebruik van mutexes in terminalserversessies. Anders kan er een DirectoryNotFoundException worden gegenereerd, ook al vertegenwoordigt de naam van de mutex een bestaand bestand.

Veiligheid thread

Dit type is thread veilig.

Zie ook

• WaitHandle
• Thread
• Het Beheerd Draadbeheer
• Mutexes-