ManualResetEvent Třída

Definice

Obor názvů:

System.Threading

Sestavení:

netstandard.dll, System.Threading.dll

Zdroj:

ManualResetEvent.cs

Představuje událost synchronizace vláken, která musí být při signálu resetována ručně. Tuto třídu nelze zdědit.

public ref class ManualResetEvent sealed : System::Threading::EventWaitHandle

public sealed class ManualResetEvent : System.Threading.EventWaitHandle

type ManualResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle

Dědičnost

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Příklady

Následující příklad ukazuje, jak ManualResetEvent funguje. Příklad začíná znakem ManualResetEvent v nepodepsaném stavu (to znamená, false že je předán konstruktoru). Příklad vytvoří tři vlákna, z nichž každý blokuje na ManualResetEvent volání své WaitOne metody. Když uživatel stiskne klávesu Enter , příklad volá metodu Set , která uvolní všechny tři vlákna. Porovnejte to s chováním AutoResetEvent třídy, která vydává vlákna po jednotlivých verzích, automaticky resetovat po každé vydané verzi.

Opětovné stisknutí klávesy Enter ukazuje, že ManualResetEvent zůstává v signalizačním stavu, dokud se jeho Reset metoda nevolá: Příklad spustí dvě více vláken. Tato vlákna neblokují při volání WaitOne metody, ale místo toho se spustí k dokončení.

Opětovné stisknutí klávesy Enter způsobí, že příklad zavolá metodu Reset a spustí další vlákno, které blokuje při volání WaitOne. Jedním posledním voláním Set klávesy Enter uvolněte poslední vlákno a program skončí.

using System;
using System.Threading;

public class Example
{
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    private static ManualResetEvent mre = new ManualResetEvent(false);

    static void Main()
    {
        Console.WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <= 2; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                          "\nto release all the threads.\n");
        Console.ReadLine();

        mre.Set();

        Thread.Sleep(500);
        Console.WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                          "\ndo not block. Press Enter to show this.\n");
        Console.ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                          "\nwhen they call WaitOne().\n");
        Console.ReadLine();

        mre.Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread t5 = new Thread(ThreadProc);
        t5.Name = "Thread_5";
        t5.Start();

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console.ReadLine();

        mre.Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console.ReadLine();
    }

    private static void ThreadProc()
    {
        string name = Thread.CurrentThread.Name;

        Console.WriteLine(name + " starts and calls mre.WaitOne()");

        mre.WaitOne();

        Console.WriteLine(name + " ends.");
    }
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre.WaitOne()
Thread_1 starts and calls mre.WaitOne()
Thread_2 starts and calls mre.WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_0 ends.
Thread_1 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre.WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre.WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre.WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */

Imports System.Threading

Public Class Example

    ' mre is used to block and release threads manually. It is
    ' created in the unsignaled state.
    Private Shared mre As New ManualResetEvent(False)

    <MTAThreadAttribute> _
    Shared Sub Main()

        Console.WriteLine(vbLf & _
            "Start 3 named threads that block on a ManualResetEvent:" & vbLf)

        For i As Integer = 0 To 2
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When all three threads have started, press Enter to call Set()" & vbLf & _
            "to release all the threads." & vbLf)
        Console.ReadLine()

        mre.Set()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When a ManualResetEvent is signaled, threads that call WaitOne()" & vbLf & _
            "do not block. Press Enter to show this." & vbLf)
        Console.ReadLine()

        For i As Integer = 3 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "Press Enter to call Reset(), so that threads once again block" & vbLf & _
            "when they call WaitOne()." & vbLf)
        Console.ReadLine()

        mre.Reset()

        ' Start a thread that waits on the ManualResetEvent.
        Dim t5 As New Thread(AddressOf ThreadProc)
        t5.Name = "Thread_5"
        t5.Start()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & "Press Enter to call Set() and conclude the demo.")
        Console.ReadLine()

        mre.Set()

        ' If you run this example in Visual Studio, uncomment the following line:
        'Console.ReadLine()

    End Sub


    Private Shared Sub ThreadProc()

        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine(name & " starts and calls mre.WaitOne()")

        mre.WaitOne()

        Console.WriteLine(name & " ends.")

    End Sub

End Class

' This example produces output similar to the following:
'
'Start 3 named threads that block on a ManualResetEvent:
'
'Thread_0 starts and calls mre.WaitOne()
'Thread_1 starts and calls mre.WaitOne()
'Thread_2 starts and calls mre.WaitOne()
'
'When all three threads have started, press Enter to call Set()
'to release all the threads.
'
'
'Thread_2 ends.
'Thread_0 ends.
'Thread_1 ends.
'
'When a ManualResetEvent is signaled, threads that call WaitOne()
'do not block. Press Enter to show this.
'
'
'Thread_3 starts and calls mre.WaitOne()
'Thread_3 ends.
'Thread_4 starts and calls mre.WaitOne()
'Thread_4 ends.
'
'Press Enter to call Reset(), so that threads once again block
'when they call WaitOne().
'
'
'Thread_5 starts and calls mre.WaitOne()
'
'Press Enter to call Set() and conclude the demo.
'
'Thread_5 ends.

Poznámky

Použijete ManualResetEvent, AutoResetEventa EventWaitHandle pro interakci s vlákny (nebo signalizaci vlákna). Další informace najdete v části Interakce s vlákny nebo signalizační část článku Přehled primitiv synchronizace .

Když vlákno zahájí aktivitu, která musí být dokončena před dalšími vlákny pokračovat, volá ManualResetEvent.Reset umístit ManualResetEvent do nesignalovaného stavu. Toto vlákno lze považovat za řízení ManualResetEvent. Vlákna, která volají ManualResetEvent.WaitOne block a čekají na signál. Když řídicí vlákno dokončí aktivitu, volá ManualResetEvent.Set signál, že čekající vlákna mohou pokračovat. Uvolní se všechna čekající vlákna.

Jakmile je signalizován, zůstává signalizován, ManualResetEvent dokud se ručně resetuje voláním Reset() metody. To znamená, že volání, která se mají WaitOne vrátit okamžitě.

Počáteční stav objektu ManualResetEvent můžete řídit předáním logické hodnoty konstruktoru: true pokud je počáteční stav signalován, a false v opačném případě.

ManualResetEvent lze také použít s metodami staticWaitAll a WaitAny metodami.

Počínaje rozhraním .NET Framework verze 2.0 ManualResetEvent se odvozuje od třídy EventWaitHandle. A ManualResetEvent je funkčně ekvivalentní vytvořenému EventWaitHandle pomocí EventResetMode.ManualReset.

Poznámka

ManualResetEvent Na rozdíl od třídy EventWaitHandle poskytuje třída přístup k pojmenovanými událostem synchronizace systému.

Počínaje .NET Framework verze 4.0 je třída System.Threading.ManualResetEventSlim jednoduchou alternativou k ManualResetEvent.

Konstruktory

Name	Description
ManualResetEvent(Boolean)	Inicializuje novou instanci ManualResetEvent třídy s logickou hodnotou označující, zda má být počáteční stav signalizován.

Pole

Name	Description
WaitTimeout	Označuje, že WaitAny(WaitHandle[], Int32, Boolean) operace vypršela před signálem jakéhokoli z popisovačů čekání. Toto pole je konstantní. (Zděděno od WaitHandle)

Vlastnosti

Name	Description
Handle	Zastaralé. Získá nebo nastaví nativní popisovač operačního systému. (Zděděno od WaitHandle)
SafeWaitHandle	Získá nebo nastaví nativní popisovač operačního systému. (Zděděno od WaitHandle)

Metody

Name	Description
Close()	Uvolní všechny prostředky uchovávané aktuálním WaitHandle. (Zděděno od WaitHandle)
Dispose()	Uvolní všechny prostředky používané aktuální instancí WaitHandle třídy. (Zděděno od WaitHandle)
Dispose(Boolean)	Při přepsání v odvozené třídě uvolní nespravované prostředky používané nástrojem WaitHandlea volitelně uvolní spravované prostředky. (Zděděno od WaitHandle)
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
Reset()	Nastaví stav události na nepřiřazené, což způsobuje blokování vláken. (Zděděno od EventWaitHandle)
Set()	Nastaví stav události, která signalizovala, což umožňuje pokračování jednoho nebo více čekacích vláken. (Zděděno od EventWaitHandle)
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
WaitOne()	Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál. (Zděděno od WaitHandle)
WaitOne(Int32, Boolean)	Zablokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určí časový interval a určí, jestli se má před čekáním ukončit synchronizační doména. (Zděděno od WaitHandle)
WaitOne(Int32)	Blokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určuje časový interval v milisekundách. (Zděděno od WaitHandle)
WaitOne(TimeSpan, Boolean)	Zablokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí parametru TimeSpan a určí, zda se má před čekáním ukončit synchronizační doména. (Zděděno od WaitHandle)
WaitOne(TimeSpan)	Blokuje aktuální vlákno, dokud aktuální instance neobdrží signál pomocí TimeSpan k určení časového intervalu. (Zděděno od WaitHandle)

Metody rozšíření

Name	Description
GetAccessControl(EventWaitHandle)	Vrátí popisovače zabezpečení pro zadanou handlehodnotu .
GetSafeWaitHandle(WaitHandle)	Získá bezpečný popisovač pro nativní obslužný rutina čekání operačního systému.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Nastaví popisovače zabezpečení pro zadaný popisovač čekání na událost.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Nastaví bezpečný popisovač pro nativní obslužný rutinu čekání operačního systému.

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

Tato třída je bezpečná pro přístup z více vláken.

Viz také

• WaitHandle
• spravovaných vláken
• Přehled primitiv synchronizace