ManualResetEvent Класс

Определение

Представляет событие синхронизации потока, которое при получении сигнала необходимо сбросить вручную.Represents a thread synchronization event that, when signaled, must be reset manually. Этот класс не может быть унаследован.This class cannot be inherited.

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
Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle
Public NotInheritable Class ManualResetEvent
Inherits WaitHandle
Наследование
ManualResetEvent
Наследование
Наследование
Атрибуты

Примеры

В следующем примере показано, как работает ManualResetEvent.The following example demonstrates how ManualResetEvent works. Пример начинается с ManualResetEvent в несигнальном состоянии (то есть false передается в конструктор).The example starts with a ManualResetEvent in the unsignaled state (that is, false is passed to the constructor). В примере создаются три потока, каждый из которых блокирует ManualResetEvent путем вызова его метода WaitOne.The example creates three threads, each of which blocks on the ManualResetEvent by calling its WaitOne method. Когда пользователь нажимает клавишу Ввод , в примере вызывается метод Set, который освобождает все три потока.When the user presses the Enter key, the example calls the Set method, which releases all three threads. Сравните это с поведением класса AutoResetEvent, который освобождает потоки по одному за раз, переустанавливая их автоматически после каждого выпуска.Contrast this with the behavior of the AutoResetEvent class, which releases threads one at a time, resetting automatically after each release.

Повторное нажатие клавиши Ввод демонстрирует, что ManualResetEvent остается в сигнальном состоянии до тех пор, пока не будет вызван метод Reset: в примере запускаются два потока.Pressing the Enter key again demonstrates that the ManualResetEvent remains in the signaled state until its Reset method is called: The example starts two more threads. Эти потоки не блокируются при вызове метода WaitOne, а выполняются до завершения.These threads do not block when they call the WaitOne method, but instead run to completion.

Повторное нажатие клавиши Ввод приводит к тому, что в примере вызывается метод Reset и запускается еще один поток, который блокируется при вызове WaitOne.Pressing the Enter key again causes the example to call the Reset method and to start one more thread, which blocks when it calls WaitOne. Нажимая клавишу Ввод , вы вызываете Set, чтобы освободить последний поток, и программа завершается.Pressing the Enter key one final time calls Set to release the last thread, and the program ends.

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.

Комментарии

Для взаимодействия потоков (или потоковых сигналов) используются ManualResetEvent, AutoResetEventи EventWaitHandle.You use ManualResetEvent, AutoResetEvent, and EventWaitHandle for thread interaction (or thread signaling). Дополнительные сведения см. в разделе взаимодействие потоков или сигнализация статьи Общие сведения о примитивах синхронизации .For more information, see the Thread interaction, or signaling section of the Overview of synchronization primitives article.

Когда поток начинает действие, которое должно быть завершено до продолжения других потоков, оно вызывает ManualResetEvent. Reset , чтобы перевести ManualResetEvent в несигнальное состояние.When a thread begins an activity that must complete before other threads proceed, it calls ManualResetEvent.Reset to put ManualResetEvent in the non-signaled state. Этот поток можно рассматривать как управление ManualResetEvent.This thread can be thought of as controlling the ManualResetEvent. Потоки, вызывающие блок ManualResetEvent. WaitOne , ожидающие сигнал.Threads that call ManualResetEvent.WaitOne block, awaiting the signal. Когда управляющий поток завершает действие, он вызывает ManualResetEvent. Set , чтобы сообщить о том, что ожидание потоков может быть продолжено.When the controlling thread completes the activity, it calls ManualResetEvent.Set to signal that the waiting threads can proceed. Освобождаются все ожидающие потоки.All waiting threads are released.

После получения сигнала ManualResetEvent остается сигнальным до тех пор, пока он не будет сброшен вручную путем вызова метода Reset().Once it has been signaled, ManualResetEvent remains signaled until it is manually reset by calling the Reset() method. То есть вызовы WaitOne возвращаться немедленно.That is, calls to WaitOne return immediately.

Вы можете управлять начальным состоянием ManualResetEvent, передав конструктору логическое значение: true, если исходное состояние сигнальное, и false в противном случае.You can control the initial state of a ManualResetEvent by passing a Boolean value to the constructor: true if the initial state is signaled, and false otherwise.

ManualResetEvent также можно использовать с методами static WaitAll и WaitAny.ManualResetEvent can also be used with the static WaitAll and WaitAny methods.

Начиная с версии .NET Framework 2,0, ManualResetEvent является производным от класса EventWaitHandle.Beginning with the .NET Framework version 2.0, ManualResetEvent derives from the EventWaitHandle class. ManualResetEvent функционально эквивалентен EventWaitHandle, созданному с помощью EventResetMode.ManualReset.A ManualResetEvent is functionally equivalent to an EventWaitHandle created with EventResetMode.ManualReset.

Примечание

В отличие от класса ManualResetEvent класс EventWaitHandle предоставляет доступ к именованным событиям системной синхронизации.Unlike the ManualResetEvent class, the EventWaitHandle class provides access to named system synchronization events.

Начиная с версии .NET Framework 4,0, класс System.Threading.ManualResetEventSlim является упрощенной альтернативой ManualResetEvent.Beginning with the .NET Framework version 4.0, the System.Threading.ManualResetEventSlim class is a lightweight alternative to ManualResetEvent.

Конструкторы

ManualResetEvent(Boolean)

Инициализирует новый экземпляр класса ManualResetEvent логическим значением, показывающим наличие сигнального состояния.Initializes a new instance of the ManualResetEvent class with a Boolean value indicating whether to set the initial state to signaled.

Поля

WaitTimeout

Указывает, что время ожидания операции WaitAny(WaitHandle[], Int32, Boolean) истекло до получения сигнала каким-либо из дескрипторов ожидания.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Это поле имеет постоянное значение.This field is constant.

(Унаследовано от WaitHandle)

Свойства

Handle

Возвращает или задает собственный дескриптор операционной системы.Gets or sets the native operating system handle.

(Унаследовано от WaitHandle)
SafeWaitHandle

Возвращает или задает собственный дескриптор операционной системы.Gets or sets the native operating system handle.

(Унаследовано от WaitHandle)

Методы

Close()

Освобождает все ресурсы, удерживаемые текущим объектом WaitHandle.Releases all resources held by the current WaitHandle.

(Унаследовано от WaitHandle)
CreateObjRef(Type)

Создает объект, который содержит всю необходимую информацию для создания прокси-сервера, используемого для взаимодействия с удаленным объектом.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Унаследовано от MarshalByRefObject)
Dispose()

Освобождает все ресурсы, используемые текущим экземпляром класса WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Унаследовано от WaitHandle)
Dispose(Boolean)

При переопределении в производном классе освобождает неуправляемые ресурсы, используемые объектом WaitHandle, и при необходимости освобождает управляемые ресурсы.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Унаследовано от WaitHandle)
Equals(Object)

Определяет, равен ли заданный объект текущему объекту.Determines whether the specified object is equal to the current object.

(Унаследовано от Object)
GetAccessControl()

Получает объект EventWaitHandleSecurity, представляющий параметры безопасности управления доступом для именованного системного события, представленного текущим объектом EventWaitHandle.Gets an EventWaitHandleSecurity object that represents the access control security for the named system event represented by the current EventWaitHandle object.

(Унаследовано от EventWaitHandle)
GetHashCode()

Служит хэш-функцией по умолчанию.Serves as the default hash function.

(Унаследовано от Object)
GetLifetimeService()

Извлекает объект обслуживания во время существования, который управляет политикой времени существования данного экземпляра.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Унаследовано от MarshalByRefObject)
GetType()

Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance.

(Унаследовано от Object)
InitializeLifetimeService()

Получает объект службы времени существования для управления политикой времени существования для этого экземпляра.Obtains a lifetime service object to control the lifetime policy for this instance.

(Унаследовано от MarshalByRefObject)
MemberwiseClone()

Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object.

(Унаследовано от Object)
MemberwiseClone(Boolean)

Создает неполную копию текущего объекта MarshalByRefObject.Creates a shallow copy of the current MarshalByRefObject object.

(Унаследовано от MarshalByRefObject)
Reset()

Задает несигнальное состояние события, вызывая блокирование потоков.Sets the state of the event to nonsignaled, which causes threads to block.

Reset()

Задает несигнальное состояние события, вызывая блокирование потоков.Sets the state of the event to nonsignaled, causing threads to block.

(Унаследовано от EventWaitHandle)
Set()

Задает сигнальное состояние события, позволяя одному или нескольким ожидающим потокам развертываться.Sets the state of the event to signaled, which allows one or more waiting threads to proceed.

Set()

Устанавливает сигнальное состояние события, что позволяет продолжить выполнение одному или нескольким ожидающим потокам.Sets the state of the event to signaled, allowing one or more waiting threads to proceed.

(Унаследовано от EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)

Задает защиту управления доступом для именованного системного события.Sets the access control security for a named system event.

(Унаследовано от EventWaitHandle)
ToString()

Возвращает строку, представляющую текущий объект.Returns a string that represents the current object.

(Унаследовано от Object)
WaitOne()

Блокирует текущий поток до получения сигнала объектом WaitHandle.Blocks the current thread until the current WaitHandle receives a signal.

(Унаследовано от WaitHandle)
WaitOne(Int32)

Блокирует текущий поток до получения текущим дескриптором WaitHandle сигнала, используя 32-разрядное целое число со знаком для указания интервала времени в миллисекундах.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Унаследовано от WaitHandle)
WaitOne(Int32, Boolean)

Блокирует текущий поток до получения сигнала текущим объектом WaitHandle, используя 32-разрядное целое число со знаком для задания периода времени и указывая, следует ли выйти из домена синхронизации до начала ожидания.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Унаследовано от WaitHandle)
WaitOne(TimeSpan)

Блокирует текущий поток до получения сигнала текущим экземпляром, используя значение типа TimeSpan для указания интервала времени.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Унаследовано от WaitHandle)
WaitOne(TimeSpan, Boolean)

Блокирует текущий поток до получения сигнала текущим экземпляром, используя значение типа TimeSpan для задания интервала времени и указывая, следует ли выйти из домена синхронизации до начала ожидания.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Унаследовано от WaitHandle)

Явные реализации интерфейса

IDisposable.Dispose()

Освобождает все ресурсы, используемые WaitHandle.Releases all resources used by the WaitHandle.

(Унаследовано от WaitHandle)

Методы расширения

GetAccessControl(EventWaitHandle)

Returns the security descriptors for the specified handle.

SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)

Sets the security descriptors for the specified event wait handle.

GetSafeWaitHandle(WaitHandle)

Возвращает безопасный дескриптор для собственного дескриптора ожидания операционной системы.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Задает безопасный дескриптор для собственного дескриптора ожидания операционной системы.Sets a safe handle for a native operating system wait handle.

Применяется к

Потокобезопасность

Этот класс является потокобезопасным.This class is thread safe.

Дополнительно