Mutex Sınıf

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kod:

System.Threading.dll

Source:

Mutex.cs

İşlemler arası eşitleme için de kullanılabilecek bir eşitleme temel öğesi.

public ref class Mutex sealed : System::Threading::WaitHandle

public sealed class Mutex : System.Threading.WaitHandle

type Mutex = class
    inherit WaitHandle

Public NotInheritable Class Mutex
Inherits WaitHandle

Devralma

Object

MarshalByRefObject

WaitHandle

Mutex

Ö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.

Önemli

Bu tür arabirimini IDisposable uygular. Türünü kullanmayı bitirdiğinizde, doğrudan veya dolaylı olarak atmalısınız. Türü doğrudan atmak için yöntemini bir try/catch blok içinde çağırın.Dispose Bunu dolaylı olarak atmak için (C#'de) veya Using (Visual Basic'te) gibi using bir dil yapısı kullanın. Daha fazla bilgi için arabirim konusunun "IDisposable Uygulayan Bir Nesne Kullanma" bölümüne IDisposable bakın.

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ı.

Dikkat

Terk edilmiş bir mutex genellikle kodda ciddi bir hata olduğunu gösterir. Bir iş parçacığı mutex serbest bırakılmadan çıktığında, mutex tarafından korunan veri yapıları tutarlı bir durumda olmayabilir. Mutex'in sahipliğini istemek için bir sonraki iş parçacığı bu özel durumu işleyebilir ve veri yapılarının bütünlüğü doğrulanabilirse devam edebilir.

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.

Not

Terminal Hizmetleri çalıştıran bir sunucuda, adlandırılmış bir sistem mutex'i iki görünürlük düzeyine sahip olabilir. Adı ön ekiyle Global\başlıyorsa, mutex tüm terminal sunucusu oturumlarında görünür. Adı ön ekiyle Local\başlıyorsa, mutex yalnızca oluşturulduğu terminal sunucusu oturumunda görünür. Bu durumda, sunucudaki diğer terminal sunucusu oturumlarının her birinde aynı ada sahip ayrı bir mutex bulunabilir. Adlandırılmış bir mutex oluştururken bir ön ek belirtmezseniz, ön ekini Local\alır. Terminal sunucusu oturumunda, adları yalnızca ön ekleriyle farklılık gösteren iki mutex ayrı mutex'lerdir ve her ikisi de terminal sunucusu oturumundaki tüm işlemlere görünür. Diğer bir deyişle, ön ek adları Global\ ve Local\ işlemlere göre değil terminal sunucusu oturumlarına göre mutex adının kapsamını açıklar.

Dikkat

Varsayılan olarak, adlandırılmış bir mutex onu oluşturan kullanıcıyla sınırlı değildir. Diğer kullanıcılar mutex'i açabilir ve kullanabilir, örneğin mutex'e girerek mutekse müdahale edebilir ve bu durumdan çıkamayabilirler. Unix benzeri işletim sistemlerinde, dosya sistemi adlandırılmış mutex'lerin uygulanmasında kullanılır ve diğer kullanıcılar adlandırılmış mutex'lere daha önemli yollarla müdahale edebilir. Windows'da belirli kullanıcılara erişimi kısıtlamak için bir oluşturucu aşırı yüklemesi kullanabilir veya MutexAcl adlandırılmış mutex'i oluştururken bir MutexSecurity geçirebilirsiniz. Unix benzeri işletim sistemlerinde şu anda adlandırılmış bir mutex'e erişimi kısıtlamanın bir yolu yoktur. Kod çalıştıran güvenilmeyen kullanıcılara sahip olabilecek sistemlerde erişim kısıtlamaları olmadan adlandırılmış mutex'leri kullanmaktan kaçının.

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

Mutex()	Sınıfın Mutex yeni bir örneğini varsayılan özelliklerle başlatır.
Mutex(Boolean)	Sınıfının yeni bir örneğini çağıran iş parçacığının Mutex mutex'in ilk sahipliğini alıp almayacağını belirten bir Boole değeriyle başlatır.
Mutex(Boolean, String)	Sınıfının yeni bir örneğini çağıran iş parçacığının Mutex mutex'in ilk sahipliğini ve mutex'in adı olan bir dizeyi alıp almayacağını belirten boole değeriyle başlatır.
Mutex(Boolean, String, Boolean)	Sınıfının yeni bir örneğini çağıran iş parçacığının Mutex mutex'in ilk sahipliğini, mutex'in adı olan bir dizeyi ve yöntem döndürdüğünde çağıran iş parçacığına mutex'in ilk sahipliğini verilip verilmediğini gösteren boole değeriyle başlatır.

Alanlar

WaitTimeout

Bekleme tutamaçlarından herhangi biri sinyal almadan önce bir WaitAny(WaitHandle[], Int32, Boolean) işlemin zaman aşımına uğramasını gösterir. Bu alan sabittir. (Devralındığı yer: WaitHandle)

Özellikler

Handle	Geçersiz. Yerel işletim sistemi tanıtıcısını alır veya ayarlar. (Devralındığı yer: WaitHandle)
SafeWaitHandle	Yerel işletim sistemi tanıtıcısını alır veya ayarlar. (Devralındığı yer: WaitHandle)

Yöntemler

Close()	Geçerli WaitHandletarafından tutulan tüm kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
Dispose()	WaitHandle sınıfının geçerli örneği tarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
Dispose(Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, tarafından WaitHandlekullanılan yönetilmeyen kaynakları serbest bırakır ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Geçersiz. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Geçersiz. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnenin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
OpenExisting(String)	Zaten varsa belirtilen adlı mutex'i açar.
ReleaseMutex()	Bir kez serbest Mutex bırakır.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)
TryOpenExisting(String, Mutex)	Belirtilen adlı mutex zaten varsa açar ve işlemin başarılı olup olmadığını belirten bir değer döndürür.
WaitOne()	Geçerli bir sinyal alıncaya kadar geçerli WaitHandle iş parçacığını engeller. (Devralındığı yer: WaitHandle)
WaitOne(Int32)	Geçerli iş parçacığı, milisaniye cinsinden zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir sinyal alana kadar geçerli WaitHandle iş parçacığını engeller. (Devralındığı yer: WaitHandle)
WaitOne(Int32, Boolean)	Geçerli bir sinyal alana kadar geçerli WaitHandle iş parçacığını engeller; zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanın ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtin. (Devralındığı yer: WaitHandle)
WaitOne(TimeSpan)	Geçerli örnek bir sinyal alıncaya kadar geçerli iş parçacığını engeller ve zaman aralığını belirtmek için bir TimeSpan kullanılır. (Devralındığı yer: WaitHandle)
WaitOne(TimeSpan, Boolean)	Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller; zaman aralığını belirtmek için bir TimeSpan kullanın ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtin. (Devralındığı yer: WaitHandle)

Uzantı Metotları

GetSafeWaitHandle(WaitHandle)	Yerel işletim sistemi bekleme tutamacını güvenli tutamacını alır.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Yerel işletim sistemi bekleme tutamacı için güvenli tanıtıcı ayarlar.

İş 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