WaitHandle Sınıf

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kod:

System.Runtime.dll

Kaynak:

WaitHandle.cs

Paylaşılan kaynaklara özel erişim bekleyen işletim sistemine özgü nesneleri kapsüller.

public ref class WaitHandle abstract : MarshalByRefObject, IDisposable

public abstract class WaitHandle : MarshalByRefObject, IDisposable

type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable

Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable

Devralma

Object

MarshalByRefObject

WaitHandle

Türetilmiş

System.Threading.EventWaitHandle

System.Threading.Mutex

System.Threading.Semaphore

Uygulamalar

IDisposable

Örnekler

Aşağıdaki kod örneği, Main iş parçacığı sınıfın statik WaitAny ve WaitAll yöntemlerini WaitHandle kullanarak görevlerin tamamlanmasını beklerken iki iş parçacığının arka plan görevlerini nasıl gerçekleştirebileceğini gösterir.

using namespace System;
using namespace System::Threading;

public ref class WaitHandleExample
{
    // Define a random number generator for testing.
private:
    static Random^ random = gcnew Random();
public:
    static void DoTask(Object^ state)
    {
        AutoResetEvent^ autoReset = (AutoResetEvent^) state;
        int time = 1000 * random->Next(2, 10);
        Console::WriteLine("Performing a task for {0} milliseconds.", time);
        Thread::Sleep(time);
        autoReset->Set();
    }
};

int main()
{
    // Define an array with two AutoResetEvent WaitHandles.
    array<WaitHandle^>^ handles = gcnew array<WaitHandle^> {
        gcnew AutoResetEvent(false), gcnew AutoResetEvent(false)};

    // Queue up two tasks on two different threads;
    // wait until all tasks are completed.
    DateTime timeInstance = DateTime::Now;
    Console::WriteLine("Main thread is waiting for BOTH tasks to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    WaitHandle::WaitAll(handles);
    // The time shown below should match the longest task.
    Console::WriteLine("Both tasks are completed (time waited={0})",
        (DateTime::Now - timeInstance).TotalMilliseconds);

    // Queue up two tasks on two different threads;
    // wait until any tasks are completed.
    timeInstance = DateTime::Now;
    Console::WriteLine();
    Console::WriteLine("The main thread is waiting for either task to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    int index = WaitHandle::WaitAny(handles);
    // The time shown below should match the shortest task.
    Console::WriteLine("Task {0} finished first (time waited={1}).",
        index + 1, (DateTime::Now - timeInstance).TotalMilliseconds);
}

// This code produces the following sample output.
//
// Main thread is waiting for BOTH tasks to complete.
// Performing a task for 7000 milliseconds.
// Performing a task for 4000 milliseconds.
// Both tasks are completed (time waited=7064.8052)

// The main thread is waiting for either task to complete.
// Performing a task for 2000 milliseconds.
// Performing a task for 2000 milliseconds.
// Task 1 finished first (time waited=2000.6528).

using System;
using System.Threading;

public sealed class App
{
    // Define an array with two AutoResetEvent WaitHandles.
    static WaitHandle[] waitHandles = new WaitHandle[]
    {
        new AutoResetEvent(false),
        new AutoResetEvent(false)
    };

    // Define a random number generator for testing.
    static Random r = new Random();

    static void Main()
    {
        // Queue up two tasks on two different threads;
        // wait until all tasks are completed.
        DateTime dt = DateTime.Now;
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        WaitHandle.WaitAll(waitHandles);
        // The time shown below should match the longest task.
        Console.WriteLine("Both tasks are completed (time waited={0})",
            (DateTime.Now - dt).TotalMilliseconds);

        // Queue up two tasks on two different threads;
        // wait until any task is completed.
        dt = DateTime.Now;
        Console.WriteLine();
        Console.WriteLine("The main thread is waiting for either task to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        int index = WaitHandle.WaitAny(waitHandles);
        // The time shown below should match the shortest task.
        Console.WriteLine("Task {0} finished first (time waited={1}).",
            index + 1, (DateTime.Now - dt).TotalMilliseconds);
    }

    static void DoTask(Object state)
    {
        AutoResetEvent are = (AutoResetEvent) state;
        int time = 1000 * r.Next(2, 10);
        Console.WriteLine("Performing a task for {0} milliseconds.", time);
        Thread.Sleep(time);
        are.Set();
    }
}

// This code produces output similar to the following:
//
//  Main thread is waiting for BOTH tasks to complete.
//  Performing a task for 7000 milliseconds.
//  Performing a task for 4000 milliseconds.
//  Both tasks are completed (time waited=7064.8052)
//
//  The main thread is waiting for either task to complete.
//  Performing a task for 2000 milliseconds.
//  Performing a task for 2000 milliseconds.
//  Task 1 finished first (time waited=2000.6528).

Imports System.Threading

NotInheritable Public Class App
    ' Define an array with two AutoResetEvent WaitHandles.
    Private Shared waitHandles() As WaitHandle = _
        {New AutoResetEvent(False), New AutoResetEvent(False)}
    
    ' Define a random number generator for testing.
    Private Shared r As New Random()
    
    <MTAThreadAttribute> _
    Public Shared Sub Main() 
        ' Queue two tasks on two different threads; 
        ' wait until all tasks are completed.
        Dim dt As DateTime = DateTime.Now
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.")
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(1))
        WaitHandle.WaitAll(waitHandles)
        ' The time shown below should match the longest task.
        Console.WriteLine("Both tasks are completed (time waited={0})", _
            (DateTime.Now - dt).TotalMilliseconds)
        
        ' Queue up two tasks on two different threads; 
        ' wait until any tasks are completed.
        dt = DateTime.Now
        Console.WriteLine()
        Console.WriteLine("The main thread is waiting for either task to complete.")
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(1))
        Dim index As Integer = WaitHandle.WaitAny(waitHandles)
        ' The time shown below should match the shortest task.
        Console.WriteLine("Task {0} finished first (time waited={1}).", _
            index + 1,(DateTime.Now - dt).TotalMilliseconds)
    
    End Sub
    
    Shared Sub DoTask(ByVal state As [Object]) 
        Dim are As AutoResetEvent = CType(state, AutoResetEvent)
        Dim time As Integer = 1000 * r.Next(2, 10)
        Console.WriteLine("Performing a task for {0} milliseconds.", time)
        Thread.Sleep(time)
        are.Set()
    
    End Sub
End Class

' This code produces output similar to the following:
'
'  Main thread is waiting for BOTH tasks to complete.
'  Performing a task for 7000 milliseconds.
'  Performing a task for 4000 milliseconds.
'  Both tasks are completed (time waited=7064.8052)
' 
'  The main thread is waiting for either task to complete.
'  Performing a task for 2000 milliseconds.
'  Performing a task for 2000 milliseconds.
'  Task 1 finished first (time waited=2000.6528).

Açıklamalar

WaitHandle sınıfı yerel bir işletim sistemi eşitleme tutamacını kapsüller ve çalışma zamanındaki birden çok bekleme işlemine izin veren tüm eşitleme nesnelerini temsil etmek için kullanılır. Bekleme tutamaçlarının diğer eşitleme nesneleriyle karşılaştırması için bkz. Eşitleme Temel Bilgilerine Genel Bakış.

Sınıfın WaitHandle kendisi soyut. 'den WaitHandle türetilen sınıflar, paylaşılan bir kaynağa erişimi almayı veya serbest bırakmayı belirten bir sinyal mekanizması tanımlar, ancak paylaşılan kaynaklara erişimi beklerken engellemek için devralınan WaitHandle yöntemleri kullanırlar. Türetilen WaitHandle sınıflar şunlardır:

• Sınıf Mutex . Bkz. Mutexes.

• EventWaitHandle sınıfı ve türetilmiş sınıfları AutoResetEvent ve ManualResetEvent.

• Sınıf Semaphore . Bkz. Semaphore ve SemaphoreSlim.

İş parçacıkları, 'den türetilen sınıflar tarafından devralınan örnek yöntemini WaitOneçağırarak tek bir bekleme tutamacını WaitHandleengelleyebilir.

türetilmiş sınıfları WaitHandle , iş parçacığı benzitesinde farklılık gösterir. Olay bekleme tanıtıcıları (EventWaitHandle, AutoResetEvent, ve ManualResetEvent) ve semaforlar iş parçacığı benzini içermez; herhangi bir iş parçacığı bir olay bekleme tutamacını veya semaforu işaret edebilir. Öte yandan, mutex'ler iş parçacığı benzitesine sahiptir; bir mutex'in sahibi olan iş parçacığı bunu serbest bırakmalıdır ve bir iş parçacığı sahip olmadığı bir mutex üzerinde yöntemini çağırırsa ReleaseMutex bir özel durum oluşturulur.

WaitHandle sınıfı öğesinden MarshalByRefObjecttüretildiği için, bu sınıflar uygulama etki alanı sınırları genelinde iş parçacıklarının etkinliklerini eşitlemek için kullanılabilir.

Türetilmiş sınıflarına ek olarak, WaitHandle sınıfı bir veya daha fazla eşitleme nesnesi sinyal alıncaya kadar bir iş parçacığını engelleyen bir dizi statik yönteme sahiptir. Bu modüller şunlardır:

• SignalAndWait, bir iş parçacığının bir bekleme tutamacını işaret etmesini ve hemen diğerini beklemesini sağlar.

• WaitAll, bir dizideki tüm bekleme tutamaçları sinyal alıncaya kadar bir iş parçacığının beklemesine olanak tanır.

• WaitAny, bir iş parçacığının belirtilen bekleme tutamaçlarından herhangi biri sinyal alınana kadar beklemesine olanak tanır.

Bu yöntemlerin aşırı yüklemeleri, beklemeyi bırakmak için zaman aşımı aralıkları ve beklemeye girmeden önce eşitleme bağlamından çıkma fırsatı sağlayarak diğer iş parçacıklarının eşitleme bağlamını kullanmasına olanak sağlar.

Önemli

Bu tür arabirimini IDisposable uygular. Türü veya türetilmiş bir türü 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.Close 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.

WaitHandle desenini Dispose uygular. Bkz . Dispose yöntemi uygulama. 'den WaitHandletüretdiğinizde, yerel işletim sistemi tanıtıcınızı depolamak için özelliğini kullanın SafeWaitHandle . Yönetilmeyen ek kaynaklar kullanmadığınız sürece korumalı Dispose yöntemi geçersiz kılmanız gerekmez.

Oluşturucular

WaitHandle()

WaitHandle sınıfının yeni bir örneğini başlatır.

Alanlar

InvalidHandle	Geçersiz bir yerel işletim sistemi tanıtıcısını temsil eder. Bu alan salt okunur durumdadır.
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.

Özellikler

Handle	Geçersiz. Yerel işletim sistemi tanıtıcısını alır veya ayarlar.
SafeWaitHandle	Yerel işletim sistemi tanıtıcısını alır veya ayarlar.

Yöntemler

Close()	Geçerli WaitHandletarafından tutulan tüm kaynakları serbest bırakır.
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.
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.
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)
SignalAndWait(WaitHandle, WaitHandle)	Birine sinyal gönderir WaitHandle ve diğerini bekler.
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)	WaitHandle 32 bit işaretli bir tamsayı olarak bir zaman aşımı aralığı belirterek ve beklemeye girmeden önce bağlam için eşitleme etki alanından çıkılıp çıkılmayacağını belirterek bir sinyal gönderir ve diğerinde bekler.
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)	Bir sinyal gönderir WaitHandle ve diğerinde bekler, zaman aşımı aralığını olarak TimeSpan belirtir ve beklemeye girmeden önce bağlam için eşitleme etki alanından çıkılıp çıkılmayacağını belirtir.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)
WaitAll(WaitHandle[])	Belirtilen dizideki tüm öğelerin sinyal almasını bekler.
WaitAll(WaitHandle[], Int32)	Zaman aralığını belirtmek için bir Int32 değer kullanarak belirtilen dizideki tüm öğelerin sinyal almasını bekler.
WaitAll(WaitHandle[], Int32, Boolean)	Belirtilen dizideki tüm öğelerin sinyal almasını bekler; zaman aralığını belirtmek için bir Int32 değer kullanarak ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtir.
WaitAll(WaitHandle[], TimeSpan)	Zaman aralığını belirtmek için bir TimeSpan değer kullanarak belirtilen dizideki tüm öğelerin sinyal almasını bekler.
WaitAll(WaitHandle[], TimeSpan, Boolean)	Belirtilen dizideki tüm öğelerin sinyal almasını bekler, zaman aralığını belirtmek için bir TimeSpan değer kullanarak ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtir.
WaitAny(WaitHandle[])	Belirtilen dizideki öğelerden herhangi birinin sinyal almasını bekler.
WaitAny(WaitHandle[], Int32)	Zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanarak belirtilen dizideki öğelerden herhangi birinin sinyal almasını bekler.
WaitAny(WaitHandle[], Int32, Boolean)	Zaman aralığını belirtmek için 32 bit işaretli bir tamsayı kullanarak ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirterek, belirtilen dizideki öğelerden herhangi birinin sinyal almasını bekler.
WaitAny(WaitHandle[], TimeSpan)	Zaman aralığını belirtmek için kullanarak TimeSpan belirtilen dizideki öğelerden herhangi birinin sinyal almasını bekler.
WaitAny(WaitHandle[], TimeSpan, Boolean)	Belirtilen dizideki öğelerden herhangi birinin sinyal almasını bekler; bunu kullanarak TimeSpan zaman aralığını belirtir ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtir.
WaitOne()	Geçerli bir sinyal alıncaya kadar geçerli WaitHandle iş parçacığını engeller.
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.
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.
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.
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.

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.

• İş Parçacığı Oluşturma
• İş Parçacığı Oluşturma Nesneleri ve Özellikleri
• Zaman Uyumu Sağlayıcılar
• EventWaitHandle, AutoResetEvent ve ManualResetEvent
• Semafor