ManualResetEvent Класс

Определение

Представляет событие синхронизации потока, которое при получении сигнала необходимо сбросить вручную. Этот класс не наследуется.

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

Примеры

В следующем примере показано, как ManualResetEvent работает. Пример начинается с ManualResetEvent состояния без знака (т false . е. передается конструктору). В примере создаются три потока, каждый из которых блокируется ManualResetEvent путем вызова метода WaitOne . Когда пользователь нажимает клавишу ВВОД , в примере вызывается Set метод, который освобождает все три потока. Сравните это с поведением AutoResetEvent класса, который освобождает потоки по одному за раз, сбрасывая их автоматически после каждого выпуска.

При нажатии клавиши ВВОД снова показано, что ManualResetEvent останки в сигнальном состоянии до вызова метода Reset : пример запускает еще два потока. Эти потоки не блокируются при вызове WaitOne метода, а выполняются до завершения.

При повторном нажатии клавиши ВВОД в примере вызывается Reset метод и запускается еще один поток, который блокируется при вызове WaitOne. Нажатие клавиши ВВОД один последний раз вызовов Set , чтобы освободить последний поток, и программа заканчивается.

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 для взаимодействия с потоком (или сигналов потока). Дополнительные сведения см. в разделе "Взаимодействие с потоком" или "Сигнальный" статьи "Обзор примитивов синхронизации ".

Когда поток начинает действие, которое должно завершиться до продолжения других потоков, оно вызывает ManualResetEvent.Reset , чтобы поместить ManualResetEvent его в состояние без сигнала. Этот поток можно рассматривать как управление ManualResetEvent. Потоки, вызывающие блок ManualResetEvent.WaitOne , ожидающие сигнала. Когда контролируемый поток завершает действие, он вызывает ManualResetEvent.Set , чтобы сообщить, что потоки ожидания могут продолжаться. Выпускаются все потоки ожидания.

После того как он будет сигнален, он остается сигнальным, ManualResetEvent пока он не будет сброшен вручную путем вызова Reset() метода. То есть вызовы для немедленного WaitOne возврата.

Начальное состояние можно управлять путем передачи ManualResetEvent логического значения конструктору: true если начальное состояние сигнализируется и в false противном случае.

ManualResetEventтакже можно использовать с методами и WaitAny методами static WaitAll.

Начиная с платформа .NET Framework версии 2.0, ManualResetEvent наследуется от EventWaitHandle класса. A ManualResetEvent функционально эквивалентен созданному объекту EventWaitHandle EventResetMode.ManualReset.

Примечание

ManualResetEvent В отличие от класса, EventWaitHandle класс предоставляет доступ к именованным событиям синхронизации системы.

Начиная с платформа .NET Framework версии 4.0 класс System.Threading.ManualResetEventSlim является упрощенной альтернативойManualResetEvent.

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

ManualResetEvent(Boolean)

Инициализирует новый экземпляр класса ManualResetEvent логическим значением, показывающим наличие сигнального состояния.

Поля

WaitTimeout

Указывает, что время ожидания операции WaitAny(WaitHandle[], Int32, Boolean) истекло до получения сигнала каким-либо из дескрипторов ожидания. Это поле является константой.

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

Свойства

Handle
Является устаревшей.
Является устаревшей.

Возвращает или задает собственный дескриптор операционной системы.

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

Возвращает или задает собственный дескриптор операционной системы.

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

Методы

Close()

Освобождает все ресурсы, удерживаемые текущим объектом WaitHandle.

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

Создает объект, который содержит всю необходимую информацию для создания прокси-сервера, используемого для взаимодействия с удаленным объектом.

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

Освобождает все ресурсы, используемые текущим экземпляром класса WaitHandle.

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

При переопределении в производном классе освобождает неуправляемые ресурсы, используемые объектом WaitHandle, и при необходимости освобождает управляемые ресурсы.

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

Определяет, равен ли указанный объект текущему объекту.

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

Возвращает объект EventWaitHandleSecurity, представляющий управление доступом для именованного системного события, представленного объектом EventWaitHandle.

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

Служит хэш-функцией по умолчанию.

(Унаследовано от Object)
GetLifetimeService()
Является устаревшей.

Извлекает объект обслуживания во время существования, который управляет политикой времени существования данного экземпляра.

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

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

(Унаследовано от Object)
InitializeLifetimeService()
Является устаревшей.

Получает объект службы времени существования для управления политикой времени существования для этого экземпляра.

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

Создает неполную копию текущего объекта Object.

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

Создает неполную копию текущего объекта MarshalByRefObject.

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

Задает несигнальное состояние события, вызывая блокирование потоков.

Reset()

Задает несигнальное состояние события, вызывая блокирование потоков.

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

Задает сигнальное состояние события, позволяя одному или нескольким ожидающим потокам развертываться.

Set()

Задает сигнальное состояние события, позволяя одному или нескольким ожидающим потокам продолжить.

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

Задает защиту управления доступом для именованного системного события.

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

Возвращает строку, представляющую текущий объект.

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

Блокирует текущий поток до получения сигнала объектом WaitHandle.

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

Блокирует текущий поток до получения текущим дескриптором WaitHandle сигнала, используя 32-разрядное целое число со знаком для указания интервала времени в миллисекундах.

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

Блокирует текущий поток до получения сигнала текущим объектом WaitHandle, используя 32-разрядное целое число со знаком для задания периода времени и указывая, следует ли выйти из домена синхронизации до начала ожидания.

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

Блокирует текущий поток до получения сигнала текущим экземпляром, используя значение типа TimeSpan для указания интервала времени.

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

Блокирует текущий поток до получения сигнала текущим экземпляром, используя значение типа TimeSpan для задания интервала времени и указывая, следует ли выйти из домена синхронизации до начала ожидания.

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

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

IDisposable.Dispose()

Этот API поддерживает инфраструктуру продукта и не предназначен для использования непосредственно из программного кода.

Освобождает все ресурсы, занятые модулем WaitHandle.

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

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

GetAccessControl(EventWaitHandle)

Возвращает дескрипторы безопасности для указанного handle.

SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)

Задает дескрипторы безопасности для указанного дескриптора ожидания события.

GetSafeWaitHandle(WaitHandle)

Возвращает безопасный дескриптор для собственного дескриптора ожидания операционной системы.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Задает безопасный дескриптор для собственного дескриптора ожидания операционной системы.

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

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

Этот класс является потокобезопасной.

См. также раздел