ManualResetEventSlim Třída

Reference

Definice

Obor názvů:: System.Threading

Sestavení:: System.Threading.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Představuje událost synchronizace vláken, která se při signálu musí resetovat ručně. Tato třída je jednoduchou alternativou k ManualResetEvent.

public ref class ManualResetEventSlim : IDisposable

public class ManualResetEventSlim : IDisposable

[System.Runtime.InteropServices.ComVisible(false)]
public class ManualResetEventSlim : IDisposable

type ManualResetEventSlim = class
    interface IDisposable

[<System.Runtime.InteropServices.ComVisible(false)>]
type ManualResetEventSlim = class
    interface IDisposable

Public Class ManualResetEventSlim
Implements IDisposable

Dědičnost: Object
ManualResetEventSlim

Atributy: ComVisibleAttribute

Implementuje: IDisposable

Příklady

Následující příklad ukazuje, jak použít ManualResetEventSlim.

using System;
using System.Threading;
using System.Threading.Tasks;
class MRESDemo
{

    static void Main()
    {
        MRES_SetWaitReset();
        MRES_SpinCountWaitHandle();
    }
    // Demonstrates:
    //      ManualResetEventSlim construction
    //      ManualResetEventSlim.Wait()
    //      ManualResetEventSlim.Set()
    //      ManualResetEventSlim.Reset()
    //      ManualResetEventSlim.IsSet
    static void MRES_SetWaitReset()
    {
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres3 = new ManualResetEventSlim(true);  // initialize as signaled

        // Start an asynchronous Task that manipulates mres3 and mres2
        var observer = Task.Factory.StartNew(() =>
        {
            mres1.Wait();
            Console.WriteLine("observer sees signaled mres1!");
            Console.WriteLine("observer resetting mres3...");
            mres3.Reset(); // should switch to unsignaled
            Console.WriteLine("observer signalling mres2");
            mres2.Set();
        });

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet);
        Console.WriteLine("main thread signalling mres1");
        mres1.Set(); // This will "kick off" the observer Task
        mres2.Wait(); // This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!");
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet);

        // It's good form to Dispose() a ManualResetEventSlim when you're done with it
        observer.Wait(); // make sure that this has fully completed
        mres1.Dispose();
        mres2.Dispose();
        mres3.Dispose();
    }

    // Demonstrates:
    //      ManualResetEventSlim construction w/ SpinCount
    //      ManualResetEventSlim.WaitHandle
    static void MRES_SpinCountWaitHandle()
    {
        // Construct a ManualResetEventSlim with a SpinCount of 1000
        // Higher spincount => longer time the MRES will spin-wait before taking lock
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false, 1000);
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false, 1000);

        Task bgTask = Task.Factory.StartNew(() =>
        {
            // Just wait a little
            Thread.Sleep(100);

            // Now signal both MRESes
            Console.WriteLine("Task signalling both MRESes");
            mres1.Set();
            mres2.Set();
        });

        // A common use of MRES.WaitHandle is to use MRES as a participant in 
        // WaitHandle.WaitAll/WaitAny.  Note that accessing MRES.WaitHandle will
        // result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(new WaitHandle[] { mres1.WaitHandle, mres2.WaitHandle });
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.");

        // Clean up
        bgTask.Wait();
        mres1.Dispose();
        mres2.Dispose();
    }
}

Imports System.Threading
Imports System.Threading.Tasks

Module MRESDemo

    Sub Main()

    End Sub
    ' Demonstrates:
    ' ManualResetEventSlim construction
    ' ManualResetEventSlim.Wait()
    ' ManualResetEventSlim.Set()
    ' ManualResetEventSlim.Reset()
    ' ManualResetEventSlim.IsSet
    Private Sub MRES_SetWaitReset()
        ' initialize as unsignaled
        Dim mres1 As New ManualResetEventSlim(False)
        ' initialize as unsignaled
        Dim mres2 As New ManualResetEventSlim(False)
        ' initialize as signaled
        Dim mres3 As New ManualResetEventSlim(True)

        ' Start an asynchronous Task that manipulates mres3 and mres2
        Dim observer = Task.Factory.StartNew(
            Sub()
                mres1.Wait()
                Console.WriteLine("observer sees signaled mres1!")
                Console.WriteLine("observer resetting mres3...")
                mres3.Reset()
                ' should switch to unsignaled
                Console.WriteLine("observer signalling mres2")
                mres2.[Set]()
            End Sub)

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet)
        Console.WriteLine("main thread signalling mres1")
        mres1.[Set]()
        ' This will "kick off" the observer Task
        mres2.Wait()
        ' This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!")
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet)

        ' make sure that observer has fully completed
        observer.Wait()
        ' It's good form to Dispose() a ManualResetEventSlim when you're done with it
        mres1.Dispose()
        mres2.Dispose()
        mres3.Dispose()
    End Sub

    ' Demonstrates:
    ' ManualResetEventSlim construction w/ SpinCount
    ' ManualResetEventSlim.WaitHandle
    Private Sub MRES_SpinCountWaitHandle()
        ' Construct a ManualResetEventSlim with a SpinCount of 1000
        ' Higher spincount => longer time the MRES will spin-wait before taking lock
        Dim mres1 As New ManualResetEventSlim(False, 1000)
        Dim mres2 As New ManualResetEventSlim(False, 1000)

        Dim bgTask As Task = Task.Factory.StartNew(
            Sub()
                ' Just wait a little
                Thread.Sleep(100)

                ' Now signal both MRESes
                Console.WriteLine("Task signalling both MRESes")
                mres1.[Set]()
                mres2.[Set]()
            End Sub)

        ' A common use of MRES.WaitHandle is to use MRES as a participant in 
        ' WaitHandle.WaitAll/WaitAny. Note that accessing MRES.WaitHandle will
        ' result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(New WaitHandle() {mres1.WaitHandle, mres2.WaitHandle})
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.")

        ' Wait for bgTask to complete and clean up
        bgTask.Wait()
        mres1.Dispose()
        mres2.Dispose()
    End Sub
End Module

Poznámky

Tuto třídu můžete použít k lepšímu výkonu, než ManualResetEvent kdy se očekává, že doba čekání bude velmi krátká a kdy událost nepřekračuje hranice procesu. ManualResetEventSlim používá zaneprázdněné otáčení po krátkou dobu, zatímco čeká na to, aby se událost signalizovala. Pokud jsou doby čekání krátké, může být otáčení mnohem levnější než čekání pomocí obslužných úchytů čekání. Pokud se však událost během určitého časového období nezjisťuje, ManualResetEventSlim uchýlí se k pravidelnému čekání na zpracování událostí.

Poznámka

V .NET Core a .NET 5+ je výchozí doba čekání na otáčení krátká: v pořadí 10 mikrosekund v závislosti na platformě a procesoru. Pokud očekáváte, že doba čekání bude mnohem delší, můžete tuto třídu použít místo ManualResetEvent (možná je nakonfigurovaná s méně nebo bez čekání na otáčení). Výhoda výkonu by však pravděpodobně byla pouze mezní.

Konstruktory

ManualResetEventSlim()	Inicializuje novou instanci ManualResetEventSlim třídy s počátečním stavem nepřiřazené.
ManualResetEventSlim(Boolean)	Inicializuje novou instanci ManualResetEventSlim třídy s logickou hodnotou označující, zda se má počáteční stav nastavit na signalizované.
ManualResetEventSlim(Boolean, Int32)	Inicializuje novou instanci ManualResetEventSlim třídy s logickou hodnotou označující, zda se má počáteční stav nastavit tak, aby signalizoval a zadaný počet čísel.

Vlastnosti

IsSet	Získá, zda je událost nastavena.
SpinCount	Získá počet čekání spinu, ke kterému dojde před vrácením zpět do operace čekání založeného na jádru.
WaitHandle	Získá podkladový WaitHandle objekt pro tento ManualResetEventSlim.

Metody

Dispose()	Uvolní všechny prostředky používané aktuální instancí ManualResetEventSlim třídy.
Dispose(Boolean)	Uvolní nespravované prostředky používané nástrojem ManualResetEventSlima volitelně uvolní spravované prostředky.
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetType()	Type Získá aktuální instanci. (Zděděno od Object)
MemberwiseClone()	Vytvoří použádnou kopii aktuálního souboru Object. (Zděděno od Object)
Reset()	Nastaví stav události na nepřiřazené, což způsobí zablokování vláken.
Set()	Nastaví stav události, která signalizovala, což umožňuje jedno nebo více vláken čekajících na pokračování události.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
Wait()	Zablokuje aktuální vlákno, dokud se nenastaví aktuální ManualResetEventSlim vlákno.
Wait(CancellationToken)	Zablokuje aktuální vlákno, dokud proud ManualResetEventSlim neobdrží signál při pozorování CancellationToken.
Wait(Int32)	Zablokuje aktuální vlákno, dokud se aktuální ManualResetEventSlim nenastaví, pomocí 32bitového bitového integeru k měření časového intervalu.
Wait(Int32, CancellationToken)	Zablokuje aktuální vlákno, dokud je aktuální ManualResetEventSlim nastaveno, pomocí 32bitového bitového integeru k měření časového intervalu CancellationTokenpři pozorování .
Wait(TimeSpan)	Zablokuje aktuální vlákno, dokud se aktuální ManualResetEventSlim nenastaví, pomocí TimeSpan měrné časové intervaly.
Wait(TimeSpan, CancellationToken)	Zablokuje aktuální vlákno, dokud není nastaven aktuální ManualResetEventSlim , pomocí TimeSpan měrného časového intervalu při pozorování CancellationToken.

Platí pro

Bezpečný přístup z více vláken

Všechny veřejné a chráněné členy ManualResetEventSlim jsou bezpečné pro vlákno a mohou být používány souběžně z více vláken, s výjimkou Funkce Dispose, která se musí používat pouze v případě, že všechny ostatní operace na ManualResetEventSlim dokončení a resetování, které by se měly použít pouze v případě, že k události nepřistupují žádné další vlákna.

Viz také

Přehled primitiv synchronizace

Sdílet prostřednictvím