Mutex Sınıf

Tanım

Ad Alanı:
System.Threading
Bütünleştirilmiş Kodlar:
mscorlib.dll, System.Threading.dll
Bütünleştirilmiş Kodlar:
netstandard.dll, System.Threading.dll
Bütünleştirilmiş Kod:
System.Threading.dll
Bütünleştirilmiş Kod:
mscorlib.dll
Bütünleştirilmiş Kod:
netstandard.dll
Kaynak:
Mutex.cs
Kaynak:
Mutex.cs
Kaynak:
Mutex.cs
Kaynak:
Mutex.cs
Kaynak:
Mutex.cs

İşlemler arası eşitleme için de kullanılabilecek bir eşitleme ilkel.

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 nesnenin nasıl kullanıldığı gösterilmektedir. Her çağıran iş parçacığı, mutex'in 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ığı ularsa, 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

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

Important

Bu tür IDisposable arabirimini uygular. türünü kullanmayı bitirdiğinizde, doğrudan (yöntemini çağırarak Dispose ) veya dolaylı olarak (C# gibi using bir dil yapısıyla) atmalısınız. Daha fazla bilgi için bkz . IDisposable uygulayan bir nesne kullanma.

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

  • Mutex'e ait olmadığını göstermek için işaret edilir. Bu durumda yöntemi WaitOne döndürür trueve çağıran iş parçacığı mutex'in sahipliğini varsayar 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 WaitOne parametresi olan millisecondsTimeout bir timeout yönteme yapılan çağrıda belirtilen zaman aşımı aralığı doldu. Bu durumda, WaitOne yöntemi döndürür falseve çağıran iş parçacığı artık mutex sahipliğini almak için girişimde bulunmaz. Bu durumda, mutex tarafından korunan kaynağa erişimin çağıran iş parçacığına erişiminin 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 zorlar, bu nedenle 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. Bir 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 ve WaitHandle.WaitAll yöntemlerini de çağırabilirsiniz.WaitHandle.WaitAny

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

Caution

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

Mutexler iki türdendir: adlandırılmamış yerel mutex'ler ve adlandırılmış sistem mutex'leri. Yerel bir mutex yalnızca sizin işleminizde bulunur. İşleminizde 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 adlandırılmış bir sistem mutex'ini açabilirsiniz.

Note

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

Caution

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çıp kullanabilir, örneğin mutex'e girerek mutex'e 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 belirli kullanıcılara erişimi kısıtlamak için bir oluşturucu aşırı yüklemesi veya MutexAcl kullanabilir ve adlandırılmış mutex'i oluştururken MutexSecurity geçirebilirsiniz. Unix benzeri işletim sistemlerinde şu anda adlandırılmış bir mutex'e erişimi kısıtlamanın hiçbir yolu yoktur. Kod çalıştıran güvenilmeyen kullanıcılara sahip olabilecek sistemlerde erişim kısıtlamaları olmadan adlandırılmış mutexes kullanmaktan kaçının.

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

Oluşturucular

Name Description
Mutex()

Sınıfın Mutex yeni bir örneğini varsayılan özelliklerle başlatır.
Mutex(Boolean, String, Boolean, MutexSecurity)

Sınıfının yeni bir örneğini, çağıran iş parçacığının Mutex mutex'in ilk sahipliğini, mutex adı olan bir dizeyi, yöntem döndürdüğünde çağıran iş parçacığına mutex'in ilk sahipliğini verilip verilmediğini ve adlandırılmış mutex'e uygulanacak erişim denetimi güvenliğini gösteren bir Boole değişkeniyle 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 bir Boole değeriyle başlatır.
Mutex(Boolean, String, NamedWaitHandleOptions, 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, kullanıcı kapsamı ve oturum kapsamı erişimini ayarlama seçeneklerini 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.
Mutex(Boolean, String, NamedWaitHandleOptions)

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 kullanıcı kapsamı ile oturum kapsamı erişimini ayarlama seçeneklerini gösteren 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)

Sınıfının yeni bir örneğini çağıran iş parçacığının Mutex mutex'in ilk sahipliğine sahip olup olmayacağını gösteren boole değeriyle başlatır.
Mutex(String, NamedWaitHandleOptions)

Kullanıcı kapsamı ve oturum kapsamı erişimini ayarlama seçenekleri ve mutex adı olan bir dize ile sınıfının yeni bir örneğini Mutex başlatır. Çağıran iş parçacığı mutex'in ilk sahipliğini istemez.

Alanlar

Name Description
WaitTimeout

Bekleme tutamaçlarından herhangi biri işaretlenmeden ö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

Name Description
Handle
Geçersiz.
Geçersiz.

Yerel işletim sistemi tutamacını alır veya ayarlar.

(Devralındığı yer: WaitHandle)
SafeWaitHandle

Yerel işletim sistemi tutamacını alır veya ayarlar.

(Devralındığı yer: WaitHandle)

Yöntemler

Name Description
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()

Sınıfın geçerli örneği WaitHandle 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)
GetAccessControl()

Adlandırılmış mutex için erişim denetimi güvenliğini temsil eden bir MutexSecurity nesne alır.
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()

Geçerli örneğin Type 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 Objectbasit 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, MutexRights)

Belirtilen adlı mutex'i, zaten varsa, istenen güvenlik erişimiyle açar.
OpenExisting(String, NamedWaitHandleOptions)

Belirtilen adlandırılmış mutex zaten varsa açar. Seçenekler yalnızca geçerli kullanıcıya ayarlanırsa, nesnenin erişim denetimleri çağıran kullanıcı için doğrulanır.
OpenExisting(String)

Belirtilen adlandırılmış mutex zaten varsa açar.
ReleaseMutex()

Bir kez serbest Mutex bırakır.
SetAccessControl(MutexSecurity)

Adlandırılmış bir sistem mutex'i için erişim denetimi güvenliğini ayarlar.
ToString()

Geçerli nesneyi temsil eden bir dize döndürür.

(Devralındığı yer: Object)
TryOpenExisting(String, Mutex)

Belirtilen adlandırılmış mutex zaten varsa açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür.
TryOpenExisting(String, MutexRights, Mutex)

Belirtilen adlı mutex'i ( zaten varsa) istenen güvenlik erişimiyle açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür.
TryOpenExisting(String, NamedWaitHandleOptions, Mutex)

Belirtilen adlandırılmış mutex zaten varsa açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür. Seçenekler yalnızca geçerli kullanıcıya ayarlanırsa, nesnenin erişim denetimleri çağıran kullanıcı için doğrulanır.
WaitOne()

Geçerli iş parçacığını, geçerli WaitHandle bir sinyal alıncaya kadar engeller.

(Devralındığı yer: WaitHandle)
WaitOne(Int32, Boolean)

Geçerli iş parçacığını, zaman aralığını belirtmek ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir WaitHandle sinyal alana kadar geçerli iş parçacığını engeller.

(Devralındığı yer: WaitHandle)
WaitOne(Int32)

Geçerli iş parçacığını, milisaniye cinsinden zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanarak, geçerli WaitHandle iş parçacığını bir sinyal alana kadar engeller.

(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 kullanarak TimeSpan ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtir.

(Devralındığı yer: WaitHandle)
WaitOne(TimeSpan)

Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller ve zaman aralığını belirtmek için bir TimeSpan kullanılır.

(Devralındığı yer: WaitHandle)

Belirtik Arabirim Kullanımları

Name Description
IDisposable.Dispose()

Bu API, ürün altyapısını destekler ve doğrudan kodunuzdan kullanıma yönelik değildir.

tarafından WaitHandlekullanılan tüm kaynakları serbest bırakır.

(Devralındığı yer: WaitHandle)

Uzantı Metotları

Name Description
GetAccessControl(Mutex)

Belirtilen mutexiçin güvenlik tanımlayıcılarını döndürür.
GetSafeWaitHandle(WaitHandle)

Yerel işletim sistemi bekleme tutamacını güvenli tutamacını alır.
SetAccessControl(Mutex, MutexSecurity)

Belirtilen mutex için güvenlik tanımlayıcılarını ayarlar.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Yerel işletim sistemi bekleme tutamacı için güvenli bir tanıtıcı ayarlar.

Şunlara uygulanır

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

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

Ayrıca bkz.