ManualResetEvent Třída

Definice

Obor názvů:

System.Threading

Sestavení:

System.Threading.dll

Zdroj:

ManualResetEvent.cs

Představuje událost synchronizace vláken, která se při signálu musí resetovat ručně. Tuto třídu nelze dě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 ve stavu bez znaménka (to znamená, false že je předán konstruktoru). Příklad vytvoří tři vlákna, z nichž každé zablokuje voláním ManualResetEvent své WaitOne metody. Když uživatel stiskne klávesu Enter , příklad zavolá metodu Set , která uvolní všechna tři vlákna. Porovnejte to s chováním AutoResetEvent třídy, která uvolňuje vlákna po jednom a automaticky resetuje po každé vydané verzi.

Opětovné stisknutí klávesy Enter ukazuje, že ManualResetEvent zůstane v signalizačním stavu, dokud není volána jeho Reset metoda: Příklad spustí další dvě vlákna. Tato vlákna neblokují, když volají metodu WaitOne , 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é při volání WaitOnezablokuje . Stisknutí klávesy Enter po jednom posledním volání Set , aby se uvolnilo poslední vlákno, a program se ukončí.

using namespace System;
using namespace System::Threading;

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

    static void ThreadProc()
    {
        String^ name = Thread::CurrentThread->Name;

        Console::WriteLine(name + " starts and calls mre->WaitOne()");

        mre->WaitOne();

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

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

        for(int i = 0; i <=2 ; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(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 = gcnew Thread(gcnew ThreadStart(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 = gcnew Thread(gcnew ThreadStart(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();
    }
};

int main()
{
   Example::Demo();
}

/* 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_1 ends.
Thread_0 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.
 */

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

K interakci s vlákny (nebo signalizaci vlákna) se používají ManualResetEventAutoResetEvent, aEventWaitHandle. Další informace najdete v části Interakce vláken nebo signalizace v článku Přehled primitiv synchronizace .

Když vlákno zahájí aktivitu, která se musí dokončit před pokračováním jiných vláken, zavolá ManualResetEvent.Reset a uvede ManualResetEvent do nesignalovaného stavu. Toto vlákno si lze představit jako řízení .ManualResetEvent Vlákna, která volají blok ManualResetEvent.WaitOne a čekají na signál. Když řídicí vlákno dokončí aktivitu, volá ManualResetEvent.Set a signaluje, že čekající vlákna mohou pokračovat. Všechna čekající vlákna jsou uvolněna.

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

Počáteční stav ManualResetEvent můžete řídit předáním logické hodnoty konstruktoru: true pokud je signalizoval počáteční stav, a false jinak.

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

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

Poznámka

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

Počínaje rozhraním .NET Framework verze 4.0 System.Threading.ManualResetEventSlim je třída odlehčenou alternativou k ManualResetEvent.

Konstruktory

ManualResetEvent(Boolean)

Inicializuje novou instanci ManualResetEvent třídy s logickou hodnotou označující, zda se má nastavit počáteční stav na signalizované.

Pole

WaitTimeout

Označuje, že WaitAny(WaitHandle[], Int32, Boolean) časový limit operace vypršel před signálem některého z popisovačů čekání. Toto pole je konstantní. (Zděděno od WaitHandle)

Vlastnosti

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

Metody

Close()	Uvolní všechny prostředky, které má aktuální WaitHandle. (Zděděno od WaitHandle)
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy používaného ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
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é WaitHandlenástrojem a volitelně uvolní spravované prostředky. (Zděděno od WaitHandle)
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetAccessControl()	Získá EventWaitHandleSecurity objekt, který představuje zabezpečení řízení přístupu pro pojmenovanou systémovou událost reprezentovanou aktuálním EventWaitHandle objektem. (Zděděno od EventWaitHandle)
GetHashCode()	Slouží jako výchozí hashovací funkce. (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á aktuální Type instanci. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (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řazeno, což způsobí blokování vláken. (Zděděno od EventWaitHandle)
Set()	Nastaví stav události na signaled, což umožňuje pokračování jednoho nebo více čekajících vláken. (Zděděno od EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	Nastaví zabezpečení řízení přístupu pro pojmenovanou systémovou událost. (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)	Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál, pomocí 32bitového celého čísla se znaménkem určuje časový interval v milisekundách. (Zděděno od WaitHandle)
WaitOne(Int32, Boolean)	Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál. Pomocí 32bitového celého čísla se znaménkem určuje časový interval a určuje, jestli 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í parametru TimeSpan pro určení časového intervalu. (Zděděno od WaitHandle)
WaitOne(TimeSpan, Boolean)	Zablokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí parametru TimeSpan pro určení časového intervalu a určení, zda se má doména synchronizace ukončit před čekáním. (Zděděno od WaitHandle)

Metody rozšíření

GetAccessControl(EventWaitHandle)	Vrátí popisovače zabezpečení pro zadaný handle.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Nastaví popisovače zabezpečení pro zadaný popisovač čekání události.
GetSafeWaitHandle(WaitHandle)	Získá bezpečný popisovač pro nativní operační systém čekání popisovač.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Nastaví bezpečný popisovač pro čekací úchyt nativního operačního systému.

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

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

Viz také

• WaitHandle
• Spravované vlákno
• Přehled primitiv synchronizace