WaitHandle Osztály

Definíció

Névtér:

System.Threading

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

WaitHandle.cs

Olyan operációsrendszer-specifikus objektumokat foglal magában, amelyek a megosztott erőforrásokhoz való kizárólagos hozzáférésre várnak.

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

Öröklődés

Object

MarshalByRefObject

WaitHandle

Származtatott

System.Threading.EventWaitHandle

System.Threading.Mutex

System.Threading.Semaphore

Megvalósítás

IDisposable

Példák

Az alábbi példakód bemutatja, hogyan végezhet két szál háttérfeladatokat, míg a főszál megvárja, amíg a feladatok befejeződnek az WaitAny osztály statikus WaitAll és WaitHandle metódusai használatával.

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

Megjegyzések

Az WaitHandle osztály egy natív operációsrendszer-szinkronizálási leírót foglal magában, és a futtatókörnyezet összes olyan szinkronizálási objektumának megjelenítésére szolgál, amely több várakozási műveletet is lehetővé teszi. A várakozási fogópontok más szinkronizálási objektumokkal való összehasonlításához tekintse meg a szinkronizálási primitívek áttekintését.

Maga WaitHandle az osztály absztrakt. A megosztott erőforrásokhoz való hozzáférés felvételét vagy felszabadítását jelző jelző mechanizmus meghatározásából WaitHandle származtatott osztályok az örökölt WaitHandle módszerekkel blokkolják a megosztott erőforrásokhoz való hozzáférést. Az osztályok a következőkből WaitHandle származnak:

• Az Mutex osztály. Lásd : Mutexes.

• Az EventWaitHandle osztály és annak származtatott osztályai és AutoResetEventManualResetEvent.

• Az Semaphore osztály. Lásd : Semaphore és SemaphoreSlim.

A szálak blokkolhatják az egyes várakozási leírókat a példány metódusának WaitOnemeghívásával, amelyet a forrásosztályok WaitHandleörökölnek.

A származtatott osztályok WaitHandle a szál affinitásában különböznek. Az esemény várakozási fogópontjai (EventWaitHandleés AutoResetEvent) és ManualResetEventa szemaphorok nem rendelkeznek szál affinitással; bármely szál képes eseményváró fogópontot vagy szemaphore-t jelezni. A mutexek viszont szál affinitással rendelkeznek; a mutexet tartalmazó szálnak fel kell szabadítania azt, és kivételt jelent, ha egy szál meghívja a ReleaseMutex metódust egy olyan mutexre, amelyet nem birtokol.

Mivel az WaitHandle osztály származik MarshalByRefObject, ezek az osztályok használhatók a szálak tevékenységeinek szinkronizálására az alkalmazás tartományhatárai között.

A származtatott osztályokon kívül az WaitHandle osztály számos statikus metódussal is rendelkezik, amelyek blokkolják a szálat, amíg egy vagy több szinkronizálási objektum nem kap jelet. Ezek közé tartoznak:

• SignalAndWait, amely lehetővé teszi, hogy egy szál jelezzen egy várakozási fogópontot, és azonnal várjon egy másikra.

• WaitAll, amely lehetővé teszi, hogy egy szál megvárja, amíg a tömb összes várakozó fogópontja jelet nem kap.

• WaitAny, amely lehetővé teszi, hogy egy szál megvárja, amíg egy adott várakozási fogópont bármelyikét jelzi.

Ezeknek a módszereknek a túlterhelése időtúllépési időközöket biztosít a várakozás megszakításához, valamint a szinkronizálási környezetből való kilépés lehetőségét a várakozás megkezdése előtt, így más szálak is használhatják a szinkronizálási környezetet.

Important

Ez a típus implementálja a IDisposable felületet. Ha befejezte a típus vagy az abból származtatott típus használatát, közvetlenül vagy közvetve kell megsemmisítenie. A típus közvetlen ártalmatlanításához hívja meg a Close metódust egy try/finally blokkban. Közvetett módon történő elidegenítéséhez használjon olyan nyelvi szerkezetet, mint a using C#.

Ha származik, WaitHandlehasználja a SafeWaitHandle tulajdonságot a natív operációsrendszer-leíró tárolásához. A védett Dispose metódust csak akkor kell felülbírálnia, ha további nem felügyelt erőforrásokat használ.

Konstruktorok

Name	Description
WaitHandle()	Inicializálja a WaitHandle osztály új példányát.

Mezők

Name	Description
InvalidHandle	Érvénytelen natív operációsrendszer-leírót jelöl. Ez a mező csak olvasható.
WaitTimeout	Azt jelzi, hogy egy WaitAny(WaitHandle[], Int32, Boolean) művelet időtúllépést jelzett a várakozási fogópontok jelzése előtt. Ez a mező állandó.

Tulajdonságok

Name	Description
Handle	Elavult. Lekéri vagy beállítja a natív operációsrendszer-leírót.
SafeWaitHandle	Lekéri vagy beállítja a natív operációsrendszer-leírót.

Metódusok

Name	Description
Close()	Az aktuális WaitHandleerőforrás összes erőforrását felszabadítja.
Dispose()	Az osztály aktuális példánya által használt összes erőforrást felszabadítja WaitHandle .
Dispose(Boolean)	Ha egy származtatott osztályban felül van bírálva, kiadja a nem felügyelt erőforrásokat, amelyeket a WaitHandlerendszer használ, és opcionálisan felszabadítja a felügyelt erőforrásokat.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLifetimeService()	Elavult. Lekéri a példány élettartamszabályzatát vezérlő aktuális élettartam-szolgáltatásobjektumot. (Öröklődés forrása MarshalByRefObject)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
InitializeLifetimeService()	Elavult. Beolvas egy élettartam-szolgáltatásobjektumot a példány élettartam-szabályzatának szabályozásához. (Öröklődés forrása MarshalByRefObject)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemberwiseClone(Boolean)	Az aktuális MarshalByRefObject objektum sekély másolatát hozza létre. (Öröklődés forrása MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)	Jelzi az egyiket WaitHandle , és várakozik egy másikon, 32 bites aláírt egész számként megadva az időtúllépési időközt, és megadja, hogy a várakozás megkezdése előtt kilép-e a környezet szinkronizálási tartományából.
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)	Jelzi az egyiket WaitHandle , és várakozik egy másikon, megadva az időtúllépési időközt TimeSpan , és megadja, hogy a várakozás megadása előtt ki kell-e lépnie a szinkronizálási tartományból a környezethez.
SignalAndWait(WaitHandle, WaitHandle)	Jelzi az egyiket WaitHandle , és várakozik egy másikra.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
WaitAll(WaitHandle[], Int32, Boolean)	Megvárja, amíg a megadott tömb összes eleme jelet kap, egy érték használatával Int32 megadja az időintervallumot, és megadja, hogy a várakozás előtt kilép-e a szinkronizálási tartományból.
WaitAll(WaitHandle[], Int32)	Megvárja, amíg a megadott tömb összes eleme jelet kap egy érték használatával Int32 az időintervallum megadásához.
WaitAll(WaitHandle[], TimeSpan, Boolean)	Megvárja, amíg a megadott tömb összes eleme jelet kap, egy érték használatával TimeSpan megadja az időintervallumot, és megadja, hogy a várakozás előtt kilép-e a szinkronizálási tartományból.
WaitAll(WaitHandle[], TimeSpan)	Megvárja, amíg a megadott tömb összes eleme jelet kap egy érték használatával TimeSpan az időintervallum megadásához.
WaitAll(WaitHandle[])	Megvárja, amíg a megadott tömb összes eleme megkapja a jelet.
WaitAny(WaitHandle[], Int32, Boolean)	Megvárja, amíg a megadott tömb bármelyik eleme jelet kap, egy 32 bites aláírt egész számmal megadva az időintervallumot, és megadja, hogy a várakozás előtt ki kell-e lépnie a szinkronizálási tartományból.
WaitAny(WaitHandle[], Int32)	Megvárja, amíg a megadott tömb bármelyik eleme megkapja a jelet, és egy 32 bites aláírt egész számmal adja meg az időintervallumot.
WaitAny(WaitHandle[], TimeSpan, Boolean)	Megvárja, amíg a megadott tömb bármelyik eleme jelet kap, az időintervallum megadásával és annak megadásával, TimeSpan hogy a várakozás előtt kilépjen-e a szinkronizálási tartományból.
WaitAny(WaitHandle[], TimeSpan)	Megvárja, amíg a megadott tömb bármelyik eleme jelet kap az TimeSpan időintervallum megadásához.
WaitAny(WaitHandle[])	Megvárja, amíg a megadott tömb bármelyik eleme jelet kap.
WaitOne()	Blokkolja az aktuális szálat, amíg az áram WaitHandle nem kap jelet.
WaitOne(Int32, Boolean)	Blokkolja az aktuális szálat, amíg az aktuális WaitHandle nem kap jelet, egy 32 bites aláírt egész számmal adja meg az időintervallumot, és adja meg, hogy a várakozás előtt ki kell-e lépnie a szinkronizálási tartományból.
WaitOne(Int32)	Blokkolja az aktuális szálat, amíg az aktuális WaitHandle nem kap jelet, egy 32 bites aláírt egész számmal adja meg az időintervallumot ezredmásodpercben.
WaitOne(TimeSpan, Boolean)	Letiltja az aktuális szálat, amíg az aktuális példány nem kap jelet, az időintervallum megadásához és annak megadásához, TimeSpan hogy a várakozás előtt kilépjen-e a szinkronizálási tartományból.
WaitOne(TimeSpan)	Letiltja az aktuális szálat, amíg az aktuális példány nem kap jelet az TimeSpan időintervallum megadásához.

Bővítő metódusok

Name	Description
GetSafeWaitHandle(WaitHandle)	Lekéri a natív operációs rendszer várakozási fogópontjának biztonságos fogópontját.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Beállít egy biztonságos fogópontot a natív operációs rendszer várakozási fogópontjához.

Szálbiztonság

Ez a típus szálbiztos.

Lásd még

• szálkezelés
• Szálkezelő objektumok és funkciók
• Mutexes
• EventWaitHandle, AutoResetEvent és ManualResetEvent
• Semaphorok