Mutex Klass

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

Arv

Object

WaitHandle

Mutex

Arv

Object

MarshalByRefObject

WaitHandle

Mutex

Attribut

ComVisibleAttribute

Exempel

Det här exemplet visar hur ett lokalt Mutex objekt används för att synkronisera åtkomst till en skyddad resurs. Eftersom varje anropstråd blockeras tills den hämtar ägarskapet för mutexen måste den ReleaseMutex anropa metoden för att frigöra ägarskapet för 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()
    {
        // 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

I följande exempel anropar WaitOne(Int32) varje tråd metoden för att hämta mutex. Om tidsgränsintervallet förflutit returnerar falsemetoden , och tråden varken hämtar mutex eller får åtkomst till resursen som mutex skyddar. Metoden ReleaseMutex anropas endast av den tråd som hämtar 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

Kommentarer

När två eller flera trådar behöver komma åt en delad resurs samtidigt behöver systemet en synkroniseringsmekanism för att säkerställa att endast en tråd i taget använder resursen. Mutex är en synkroniseringsprimiter som ger exklusiv åtkomst till den delade resursen till endast en tråd. Om en tråd hämtar en mutex pausas den andra tråden som vill hämta mutex tills den första tråden släpper mutex.

Du kan använda WaitHandle.WaitOne metoden för att begära ägarskap för en mutex. Den anropande tråden blockerar tills något av följande inträffar:

• Mutex signaleras för att indikera att det inte ägs. När detta inträffar WaitOne returnerar truemetoden , och den anropande tråden förutsätter ägarskap för mutex och kommer åt resursen som skyddas av mutex. När den har kommit åt resursen måste tråden ReleaseMutex anropa metoden för att frigöra ägarskapet för mutex. Det första exemplet i avsnittet Exempel illustrerar det här mönstret.

• Tidsgränsintervallet som anges i anropet till en WaitOne metod som har en millisecondsTimeout eller timeout -parameter har förflutit. När detta händer WaitOne returnerar falsemetoden , och den anropande tråden gör inga ytterligare försök att hämta ägarskapet för mutex. I det här fallet bör du strukturera koden så att åtkomst till resursen som skyddas av mutex nekas till den anropande tråden. Eftersom tråden aldrig förvärvade ägarskapet för mutex får den inte anropa ReleaseMutex metoden. Det andra exemplet i avsnittet Exempel illustrerar det här mönstret.

Klassen Mutex framtvingar trådidentitet, så en mutex kan bara släppas av den tråd som hämtade den. Klassen tillämpar däremot Semaphore inte trådidentitet. En mutex kan också skickas över programdomängränser.

Tråden som äger en mutex kan begära samma mutex i upprepade anrop till utan att WaitOne blockera dess körning. Tråden måste dock anropa ReleaseMutex metoden samma antal gånger för att frigöra ägarskapet för mutex.

Mutex Eftersom klassen ärver från WaitHandlekan du även anropa statiska WaitHandle.WaitAll metoder och WaitHandle.WaitAny metoder för att synkronisera åtkomst till en skyddad resurs.

Om en tråd avslutas när den äger en mutex, sägs mutexen vara övergiven. Mutex-tillståndet är inställt på signalerat och nästa väntande tråd får ägarskap. Från och med version 2.0 av .NET Framework genereras en AbandonedMutexException i nästa tråd som hämtar den övergivna mutexen. Innan version 2.0 av .NET Framework utlöstes inget undantag.

När det gäller en systemomfattande mutex kan en övergiven mutex indikera att ett program plötsligt har avslutats (till exempel med hjälp av Windows Task Manager).

Mutexes är av två typer: lokala mutexes, som är namnlösa och namngivna system mutexes. En lokal mutex finns endast inom din process. Den kan användas av valfri tråd i processen som har en referens till objektet Mutex som representerar mutex. Varje namnlöst Mutex objekt representerar en separat lokal mutex.

Namngivna systemljud visas i hela operativsystemet och kan användas för att synkronisera processernas aktiviteter. Du kan skapa ett Mutex objekt som representerar en namngiven system mutex med hjälp av en konstruktor som accepterar ett namn. Operativsystemets objekt kan skapas samtidigt, eller så kan det finnas innan objektet skapas Mutex . Du kan skapa flera Mutex-objekt som representerar samma namngivna systemmutex, och du kan använda OpenExisting-metoden för att öppna en befintlig namngiven systemmutex.

Omvänt snedstreck (\) är ett reserverat tecken i ett mutex-namn. Använd inte ett omvänt snedstreck (\) i ett mutex-namn förutom det som anges i anteckningen om att använda mutex i terminalserversessioner. Annars kan en DirectoryNotFoundException genereras, även om namnet på mutex representerar en befintlig fil.

Trådsäkerhet

Den här typen är trådsäker.

Se även

• WaitHandle
• Thread
• hanterad trådning
• mutexes