Mutex Třída

Definice

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

Dědičnost

Object

WaitHandle

Mutex

Dědičnost

Object

MarshalByRefObject

WaitHandle

Mutex

Atributy

ComVisibleAttribute

Příklady

Tento příklad ukazuje, jak se místní Mutex objekt používá k synchronizaci přístupu k chráněnému prostředku. Vzhledem k tomu, že každé volající vlákno je blokováno, dokud nezíská vlastnictví mutexu, musí volat metodu ReleaseMutex pro uvolnění vlastnictví mutexu.

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

V následujícím příkladu každé vlákno volá metodu WaitOne(Int32) pro získání mutexu. Pokud interval časového limitu uplyne, vrátí falsemetoda hodnotu a vlákno nezíská ani přístup k prostředku, který mutex chrání. Metoda ReleaseMutex je volána pouze vláknem, které získá 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

Poznámky

Pokud dvě nebo více vláken potřebují přístup ke sdílenému prostředku najednou, systém potřebuje synchronizační mechanismus, který zajistí, že prostředek bude používat jenom jedno vlákno najednou. Mutex je primitiv synchronizace, který uděluje výhradní přístup ke sdílenému prostředku pouze jednomu vláknu. Pokud vlákno získá mutex, druhé vlákno, které chce tento mutex získat, je pozastaveno, dokud první vlákno mutex nesvolí.

Pomocí metody můžete WaitHandle.WaitOne požádat o vlastnictví mutexu. Volající vlákno blokuje, dokud nedojde k jedné z následujících:

• Mutex je signalizovat, že není vlastněný. Když k tomu dojde, WaitOne metoda vrátí truea volající vlákno převezme vlastnictví mutexu a přistupuje k prostředku chráněnému mutexem. Po dokončení přístupu k prostředku musí vlákno volat metodu ReleaseMutex pro uvolnění vlastnictví mutexu. První příklad v části Příklady znázorňuje tento vzor.

• Časový limit zadaný ve volání WaitOne metody s parametrem millisecondsTimeout nebo timeout uplynul. Když k tomu dojde, WaitOne metoda vrátí falsea volající vlákno se již nepokusí získat vlastnictví mutexu. V takovém případě byste měli kód strukturovat tak, aby byl volajícímu vláknu odepřen přístup k prostředku chráněnému mutexem. Protože vlákno nikdy nezískala vlastnictví mutexu, nesmí volat metodu ReleaseMutex . Druhý příklad v části Příklady znázorňuje tento vzor.

Třída Mutex vynucuje identitu vlákna, takže mutex může být uvolněn pouze vláknem, které ho získalo. Naproti tomu Semaphore třída nevynucuje identitu vlákna. Mutex je také možné předat přes hranice domény aplikace.

Vlákno, které vlastní mutex, může požadovat stejný mutex v opakovaných voláních bez WaitOne blokování jeho spuštění. Vlákno však musí volat metodu ReleaseMutex stejný počet, aby se uvolnilo vlastnictví mutexu.

Vzhledem k tomu, že Mutex třída dědí z WaitHandle, můžete také volat statické WaitHandle.WaitAll metody a WaitHandle.WaitAny synchronizovat přístup k chráněnému prostředku.

Pokud se vlákno ukončí při vlastnictví mutexu, říká se, že je mutex opuštěný. Stav mutexu je nastavený na signaled a další čekající vlákno získá vlastnictví. Počínaje verzí 2.0 rozhraní .NET Framework AbandonedMutexException je vyvolána v dalším vlákně, které získá opuštěný mutex. Před verzí 2.0 rozhraní .NET Framework nebyla vyvolán žádná výjimka.

V případě mutexu v celém systému může opuštěný mutex znamenat, že aplikace byla náhle ukončena (například pomocí Správce úloh systému Windows).

Mutexy jsou dvou typů: místní mutexy, které nejsou pojmenovány, a pojmenované systémové mutexy. Místní mutex existuje pouze v rámci vašeho procesu. Může být použit libovolným vláknem v procesu, které má odkaz na Mutex objekt, který představuje mutex. Každý nepojmenovaný Mutex objekt představuje samostatný místní mutex.

Pojmenované systémové mutexy jsou viditelné v celém operačním systému a dají se použít k synchronizaci aktivit procesů. Pomocí konstruktoru Mutex , který přijímá název, můžete vytvořit objekt, který představuje pojmenovaný systémový mutex. Objekt operačního systému může být vytvořen současně nebo může existovat před vytvořením objektu Mutex . Můžete vytvořit více Mutex objektů, které představují stejný pojmenovaný systémový mutex, a můžete použít metodu OpenExisting k otevření existující pojmenované systémové mutex.

Zpětné lomítko (\) je vyhrazený znak v názvu mutex. Nepoužívejte zpětné lomítko (\) v názvu mutexu s výjimkou případů uvedených v poznámce o použití mutexů v relacích terminálového serveru. V opačném DirectoryNotFoundException případě může být vyvolán, i když název mutex představuje existující soubor.

Konstruktory

Pole

Vlastnosti

Metody

Explicitní implementace rozhraní

Metody rozšíření

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.

Viz také

• WaitHandle
• Thread
• Spravované vlákno
• Mutex – třídy