Mutex Sınıf

Tanım

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

Devralma

Object

WaitHandle

Mutex

Devralma

Object

MarshalByRefObject

WaitHandle

Mutex

Öznitelikler

ComVisibleAttribute

Örnekler

Bu örnekte, korumalı bir kaynağa erişimi eşitlemek için yerel Mutex bir nesnenin nasıl kullanıldığı gösterilmektedir. Her çağıran iş parçacığı mutex sahipliğini elde edene kadar engellendiğinden, mutex'in sahipliğini serbest bırakmak için yöntemini çağırması ReleaseMutex gerekir.

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

Aşağıdaki örnekte, her iş parçacığı mutex almak için yöntemini çağırır WaitOne(Int32) . Zaman aşımı aralığı geçtikten sonra yöntemi döndürür falseve iş parçacığı ne mutex'i alır ne de mutex'in koruduğu kaynağa erişim kazanır. ReleaseMutex yöntemi yalnızca mutex'i alan iş parçacığı tarafından çağrılır.

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

Açıklamalar

İki veya daha fazla iş parçacığının paylaşılan bir kaynağa aynı anda erişmesi gerektiğinde, sistemin kaynağı aynı anda yalnızca bir iş parçacığının kullandığından emin olmak için bir eşitleme mekanizmasına ihtiyacı vardır. Mutex , paylaşılan kaynağa yalnızca bir iş parçacığına özel erişim veren bir eşitleme temel öğesidir. bir iş parçacığı bir mutex alırsa, bu mutex almak isteyen ikinci iş parçacığı ilk iş parçacığı mutex serbest bırakana kadar askıya alınır.

Bir mutex'in WaitHandle.WaitOne sahipliğini istemek için yöntemini kullanabilirsiniz. Aşağıdakilerden biri gerçekleşene kadar çağıran iş parçacığı blokları:

• Mutex'e ait olmadığını göstermek için sinyal gönderiliyor. Bu durumda yöntemi WaitOne döndürür trueve çağıran iş parçacığı mutex'in sahipliğini üstlenir ve mutex tarafından korunan kaynağa erişir. Kaynağa erişmeyi bitirdiğinde, iş parçacığının mutex'in sahipliğini serbest bırakmak için yöntemini çağırması ReleaseMutex gerekir. Örnekler bölümündeki ilk örnekte bu desen gösterilmektedir.

• veya timeout parametresi olan bir WaitOne yönteme millisecondsTimeout yapılan çağrıda belirtilen zaman aşımı aralığı doldu. Bu durumda yöntemi WaitOne döndürür falseve çağıran iş parçacığı artık mutex'in sahipliğini almayı denemez. Bu durumda, mutex tarafından korunan kaynağa erişimin çağıran iş parçacığına reddedilmesi için kodunuzu yapılandırmanız gerekir. İş parçacığı hiçbir zaman mutex'in sahipliğini almadığından yöntemini çağırmamalıdır ReleaseMutex . Örnekler bölümündeki ikinci örnekte bu desen gösterilmektedir.

Mutex sınıfı iş parçacığı kimliğini zorunlu kıldığı için bir mutex yalnızca onu alan iş parçacığı tarafından serbest bırakılabilir. Buna karşılık, Semaphore sınıfı iş parçacığı kimliğini zorlamaz. Mutex, uygulama etki alanı sınırları arasında da geçirilebilir.

Bir mutex'e sahip olan iş parçacığı, yürütmesini engellemeden yinelenen çağrılarda aynı mutex'i WaitOne isteyebilir. Ancak iş parçacığının mutex'in sahipliğini serbest bırakmak için yöntemini aynı sayıda çağırması ReleaseMutex gerekir.

sınıfı öğesinden devraldığındanMutex, korumalı bir kaynağa erişimi eşitlemek için statik WaitHandle.WaitAll ve WaitHandle.WaitAny yöntemlerini de çağırabilirsiniz.WaitHandle

Bir mutex'e sahipken bir iş parçacığı sonlandırılırsa, mutex'in terkedileceği söylenir. Mutex'in durumu işaretlenmek üzere ayarlanır ve bir sonraki bekleyen iş parçacığı sahipliği alır. .NET Framework 2.0 sürümünden başlayarak, terk edilmiş mutex'i alan sonraki iş parçacığında bir AbandonedMutexException oluşturulur. .NET Framework 2.0 sürümünden önce özel durum oluşturmadı.

Sistem genelinde bir mutex söz konusu olduğunda, terk edilmiş bir mutex bir uygulamanın aniden sonlandırıldığını gösterebilir (örneğin, Windows Görev Yöneticisi kullanılarak).

Mutexes iki türdendir: adlandırılmamış yerel mutex'ler ve adlandırılmış sistem mutex'leri. Yerel bir mutex yalnızca sizin işleminizde var. İşleminizdeki mutex'i temsil eden nesneye Mutex başvurusu olan herhangi bir iş parçacığı tarafından kullanılabilir. Adlandırılmamış Mutex her nesne ayrı bir yerel mutex'i temsil eder.

Adlandırılmış sistem mutex'leri işletim sistemi genelinde görünür ve işlemlerin etkinliklerini eşitlemek için kullanılabilir. Bir adı kabul eden bir Mutex oluşturucu kullanarak adlandırılmış sistem mutex'ini temsil eden bir nesne oluşturabilirsiniz. İşletim sistemi nesnesi aynı anda oluşturulabilir veya nesne oluşturulmadan Mutex önce var olabilir. Aynı adlandırılmış sistem mutex'ini temsil eden birden çok Mutex nesne oluşturabilir ve yöntemini kullanarak OpenExisting mevcut bir adlandırılmış sistem mutex'ini açabilirsiniz.

Ters eğik çizgi (\), bir mutex adında ayrılmış bir karakterdir. Terminal sunucusu oturumlarında mutex'leri kullanma konusunda notta belirtilenler dışında, bir mutex adında ters eğik çizgi (\) kullanmayın. Aksi takdirde, DirectoryNotFoundException mutex adı mevcut bir dosyayı temsil etse bile oluşturulabilir.

Oluşturucular

Alanlar

Özellikler

Yöntemler

Belirtik Arabirim Kullanımları

Uzantı Metotları

Şunlara uygulanır

İş Parçacığı Güvenliği

Bu güvenli iş parçacığı türüdür.

Ayrıca bkz.

• WaitHandle
• Thread
• Yönetilen İş Parçacığı Oluşturma
• Zaman Uyumu Sağlayıcılar