ManualResetEvent Třída

Definice

Obor názvů:

System.Threading

Sestavení:

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á ManualResetEvent v nepřiřazeném stavu (to znamená, false se předá konstruktoru). Příklad vytvoří tři vlákna, z nichž každý blokuje na ManualResetEvent voláním WaitOne metody. Když uživatel stiskne klávesu Enter, příklad zavolá metodu Set, která uvolní všechny tři vlákna. Porovnejte to s chováním třídy AutoResetEvent, která vydává vlákna po jednom, resetování automaticky po každé vydané verzi.

Opětovným stisknutím klávesy Enter ukazuje, že ManualResetEvent zůstává v signalizačním stavu, dokud nebude volána metoda Reset: Příklad spustí dvě další vlákna. Tato vlákna neblokují, když volají metodu WaitOne, ale místo toho se spustí k dokončení.

Dalším stisknutím klávesy Enter dojde k tomu, že příklad zavolá metodu Reset a spustí další vlákno, které blokuje volání WaitOne. Stisknutím klávesy Enter jedním posledním voláním Set uvolnit poslední vlákno a program skončí.

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

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

Když vlákno zahájí aktivitu, která musí být dokončena před pokračováním jiných vláken, 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 bloku čekající na signál. Když řídicí vlákno dokončí aktivitu, volá ManualResetEvent.Set signalizovat, že čekající vlákna mohou pokračovat. Uvolní se všechna čekající vlákna.

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

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

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

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

Poznámka

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

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

Konstruktory

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

WaitTimeout

Označuje, že vypršel časový limit WaitAny(WaitHandle[], Int32, Boolean) operace 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í 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

Close()	Uvolní všechny prostředky uchovávané aktuálním WaitHandle. (Zděděno od WaitHandle)
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy serveru sloužícího ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
Dispose()	Uvolní všechny prostředky používané aktuální instancí třídy WaitHandle. (Zděděno od WaitHandle)
Dispose(Boolean)	Při přepsání v odvozené třídě uvolní nespravované prostředky používané 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)
GetAccessControl()	Získá EventWaitHandleSecurity objekt, který představuje zabezpečení řízení přístupu pro pojmenovanou systém událost reprezentovaný aktuálním EventWaitHandle objektu. (Zděděno od EventWaitHandle)
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 objektu MarshalByRefObject. (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)
SetAccessControl(EventWaitHandleSecurity)	Nastaví zabezpečení řízení přístupu pro pojmenovanou událost systému. (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 aktuální WaitHandle neobdrží signál. (Zděděno od WaitHandle)
WaitOne(Int32)	Blokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál pomocí 32bitového znaménka k určení časového intervalu v milisekundách. (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čí, 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)
WaitOne(TimeSpan, Boolean)	Blokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí TimeSpan určit časový interval a určit, zda se má před čekáním ukončit synchronizační doména. (Zděděno od WaitHandle)

Metody rozšíření

GetAccessControl(EventWaitHandle)	Vrátí popisovače zabezpečení pro zadanou handle.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Nastaví popisovače zabezpečení pro zadaný popisovač čekání na událost.
GetSafeWaitHandle(WaitHandle)	Získá bezpečný popisovač pro nativní obslužný rutina čekání operačního systému.
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