ManualResetEvent Klass

Definition

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

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

public sealed class ManualResetEvent : System.Threading.EventWaitHandle

public sealed class ManualResetEvent : System.Threading.WaitHandle

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ManualResetEvent : System.Threading.EventWaitHandle

type ManualResetEvent = class
    inherit EventWaitHandle

type ManualResetEvent = class
    inherit WaitHandle

[<System.Runtime.InteropServices.ComVisible(true)>]
type ManualResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits WaitHandle

Arv

Object

WaitHandle

EventWaitHandle

ManualResetEvent

Arv

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Arv

Object

MarshalByRefObject

WaitHandle

ManualResetEvent

Attribut

ComVisibleAttribute

Exempel

Följande exempel visar hur ManualResetEvent fungerar. Exemplet börjar med ett ManualResetEvent i osignalat tillstånd (det vill false säga skickas till konstruktorn). Exemplet skapar tre trådar, som vart och ett blockeras på ManualResetEvent genom att anropa dess WaitOne metod. När användaren trycker på Retur-tangenten anropas Set metoden i exemplet, som släpper ut alla tre trådarna. Kontrastera detta med beteendet för AutoResetEvent klassen, som släpper trådar en i taget, återställs automatiskt efter varje version.

Om du trycker på Retur-tangenten igen visas att förblir ManualResetEvent i signalerat tillstånd tills dess Reset metod anropas: Exemplet startar ytterligare två trådar. Dessa trådar blockeras inte när de anropar WaitOne metoden, utan körs i stället för att slutföras.

Om du trycker på Retur igen anropar Reset exemplet metoden och startar en tråd till, vilket blockerar när den anropar WaitOne. Om du trycker på Retur en sista gång anropas Set den sista tråden så avslutas programmet.

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.

Kommentarer

Du använder ManualResetEvent, AutoResetEventoch EventWaitHandle för trådinteraktion (eller trådsignalering). Mer information finns i avsnittet Trådinteraktion eller signalering i artikeln Översikt över synkroniseringsprimitiver .

När en tråd börjar en aktivitet som måste slutföras innan andra trådar fortsätter anropas ManualResetEvent.Reset för att placera ManualResetEvent i icke-signalerat tillstånd. Den här tråden kan anses styra ManualResetEvent. Trådar som anropar ManualResetEvent.WaitOne-block som väntar på signalen. När den kontrollerande tråden slutför aktiviteten anropas ManualResetEvent.Set för att signalera att de väntande trådarna kan fortsätta. Alla väntande trådar släpps.

När den har signalerats ManualResetEvent förblir den signalerad tills den återställs manuellt genom att anropa Reset() metoden. Det vill s.v.s. anrop att WaitOne återkomma omedelbart.

Du kan styra det initiala tillståndet för en ManualResetEvent genom att skicka ett booleskt värde till konstruktorn: true om det ursprungliga tillståndet signaleras och false annars.

ManualResetEvent kan också användas med staticWaitAll metoderna och WaitAny .

Från och med .NET Framework version 2.0 härleds ManualResetEvent från klassen EventWaitHandle. A ManualResetEvent är funktionellt likvärdigt med en EventWaitHandle som skapats med EventResetMode.ManualReset.

Från och med .NET Framework version 4.0 är klassen System.Threading.ManualResetEventSlim ett enkelt alternativ till ManualResetEvent.

Trådsäkerhet

Den här klassen är trådsäker.

Se även

• WaitHandle
• hanterad trådning
• Översikt över synkroniseringsprimitiver