WaitHandle.SignalAndWait Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Threading

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Sygnalizuje jeden WaitHandle i czeka na inny.

Przeciążenia

SignalAndWait(WaitHandle, WaitHandle)	Sygnalizuje jeden WaitHandle i czeka na inny.
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)	Sygnalizuje jeden WaitHandle i czeka na inny, określając interwał limitu czasu jako 32-bitową liczbę całkowitą podpisaną i określając, czy należy zamknąć domenę synchronizacji dla kontekstu przed wprowadzeniem oczekiwania.
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)	Sygnalizuje jeden WaitHandle i czeka na inny, określając interwał limitu czasu jako i TimeSpan określając, czy należy zamknąć domenę synchronizacji dla kontekstu przed wprowadzeniem oczekiwania.

SignalAndWait(WaitHandle, WaitHandle)

Źródło:: WaitHandle.cs

Źródło:: WaitHandle.cs

Źródło:: WaitHandle.cs

Sygnalizuje jeden WaitHandle i czeka na inny.

public:
 static bool SignalAndWait(System::Threading::WaitHandle ^ toSignal, System::Threading::WaitHandle ^ toWaitOn);

public static bool SignalAndWait (System.Threading.WaitHandle toSignal, System.Threading.WaitHandle toWaitOn);

static member SignalAndWait : System.Threading.WaitHandle * System.Threading.WaitHandle -> bool

Public Shared Function SignalAndWait (toSignal As WaitHandle, toWaitOn As WaitHandle) As Boolean

Parametry

toSignal: WaitHandle

Sygnał WaitHandle to.

toWaitOn: WaitHandle

Zaczekaj WaitHandle na.

Zwraca

Boolean

true jeśli sygnał i oczekiwanie zakończyły się pomyślnie; jeśli oczekiwanie nie zostanie ukończone, metoda nie zwróci.

Wyjątki

ArgumentNullException

toSignal to null.

-lub-

toWaitOn to null.

NotSupportedException

Metoda została wywołana w wątku w STA stanie.

InvalidOperationException

toSignal jest semaforem i ma już pełną liczbę.

AbandonedMutexException

Oczekiwanie zostało zakończone, ponieważ wątek zakończył się bez zwalniania mutexu.

Przykłady

Poniższy przykład kodu używa SignalAndWait(WaitHandle, WaitHandle) przeciążenia metody, aby umożliwić głównemu wątkowi sygnalizowanie zablokowanego wątku, a następnie poczekaj, aż wątek zakończy zadanie.

Przykład uruchamia pięć wątków, umożliwia zablokowanie utworzonego EventWaitHandle elementu za pomocą flagi EventResetMode.AutoReset , a następnie zwalnia jeden wątek za każdym razem, gdy użytkownik naciska klawisz ENTER. W tym przykładzie kolejkuje kolejne pięć wątków i zwalnia je wszystkie przy użyciu utworzonej EventWaitHandle flagi EventResetMode.ManualReset .

using namespace System;
using namespace System::Threading;

public ref class Example
{
private:
   // The EventWaitHandle used to demonstrate the difference
   // between AutoReset and ManualReset synchronization events.
   //
   static EventWaitHandle^ ewh;

   // A counter to make sure all threads are started and
   // blocked before any are released. A Long is used to show
   // the use of the 64-bit Interlocked methods.
   //
   static __int64 threadCount = 0;

   // An AutoReset event that allows the main thread to block
   // until an exiting thread has decremented the count.
   //
   static EventWaitHandle^ clearCount =
      gcnew EventWaitHandle( false,EventResetMode::AutoReset );

public:
   [MTAThread]
   static void main()
   {
      // Create an AutoReset EventWaitHandle.
      //
      ewh = gcnew EventWaitHandle( false,EventResetMode::AutoReset );
      
      // Create and start five numbered threads. Use the
      // ParameterizedThreadStart delegate, so the thread
      // number can be passed as an argument to the Start
      // method.
      for ( int i = 0; i <= 4; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew ParameterizedThreadStart( ThreadProc ) );
         t->Start( i );
      }
      
      // Wait until all the threads have started and blocked.
      // When multiple threads use a 64-bit value on a 32-bit
      // system, you must access the value through the
      // Interlocked class to guarantee thread safety.
      //
      while ( Interlocked::Read( threadCount ) < 5 )
      {
         Thread::Sleep( 500 );
      }

      // Release one thread each time the user presses ENTER,
      // until all threads have been released.
      //
      while ( Interlocked::Read( threadCount ) > 0 )
      {
         Console::WriteLine( L"Press ENTER to release a waiting thread." );
         Console::ReadLine();
         
         // SignalAndWait signals the EventWaitHandle, which
         // releases exactly one thread before resetting,
         // because it was created with AutoReset mode.
         // SignalAndWait then blocks on clearCount, to
         // allow the signaled thread to decrement the count
         // before looping again.
         //
         WaitHandle::SignalAndWait( ewh, clearCount );
      }
      Console::WriteLine();
      
      // Create a ManualReset EventWaitHandle.
      //
      ewh = gcnew EventWaitHandle( false,EventResetMode::ManualReset );
      
      // Create and start five more numbered threads.
      //
      for ( int i = 0; i <= 4; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew ParameterizedThreadStart( ThreadProc ) );
         t->Start( i );
      }
      
      // Wait until all the threads have started and blocked.
      //
      while ( Interlocked::Read( threadCount ) < 5 )
      {
         Thread::Sleep( 500 );
      }

      // Because the EventWaitHandle was created with
      // ManualReset mode, signaling it releases all the
      // waiting threads.
      //
      Console::WriteLine( L"Press ENTER to release the waiting threads." );
      Console::ReadLine();
      ewh->Set();

   }

   static void ThreadProc( Object^ data )
   {
      int index = static_cast<Int32>(data);

      Console::WriteLine( L"Thread {0} blocks.", data );
      // Increment the count of blocked threads.
      Interlocked::Increment( threadCount );
      
      // Wait on the EventWaitHandle.
      ewh->WaitOne();

      Console::WriteLine( L"Thread {0} exits.", data );
      // Decrement the count of blocked threads.
      Interlocked::Decrement( threadCount );
      
      // After signaling ewh, the main thread blocks on
      // clearCount until the signaled thread has
      // decremented the count. Signal it now.
      //
      clearCount->Set();
   }
};

using System;
using System.Threading;

public class Example
{
    // The EventWaitHandle used to demonstrate the difference
    // between AutoReset and ManualReset synchronization events.
    //
    private static EventWaitHandle ewh;

    // A counter to make sure all threads are started and
    // blocked before any are released. A Long is used to show
    // the use of the 64-bit Interlocked methods.
    //
    private static long threadCount = 0;

    // An AutoReset event that allows the main thread to block
    // until an exiting thread has decremented the count.
    //
    private static EventWaitHandle clearCount = 
        new EventWaitHandle(false, EventResetMode.AutoReset);

    [MTAThread]
    public static void Main()
    {
        // Create an AutoReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.AutoReset);

        // Create and start five numbered threads. Use the
        // ParameterizedThreadStart delegate, so the thread
        // number can be passed as an argument to the Start 
        // method.
        for (int i = 0; i <= 4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        // When multiple threads use a 64-bit value on a 32-bit
        // system, you must access the value through the
        // Interlocked class to guarantee thread safety.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Release one thread each time the user presses ENTER,
        // until all threads have been released.
        //
        while (Interlocked.Read(ref threadCount) > 0)
        {
            Console.WriteLine("Press ENTER to release a waiting thread.");
            Console.ReadLine();

            // SignalAndWait signals the EventWaitHandle, which
            // releases exactly one thread before resetting, 
            // because it was created with AutoReset mode. 
            // SignalAndWait then blocks on clearCount, to 
            // allow the signaled thread to decrement the count
            // before looping again.
            //
            WaitHandle.SignalAndWait(ewh, clearCount);
        }
        Console.WriteLine();

        // Create a ManualReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

        // Create and start five more numbered threads.
        //
        for(int i=0; i<=4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Because the EventWaitHandle was created with
        // ManualReset mode, signaling it releases all the
        // waiting threads.
        //
        Console.WriteLine("Press ENTER to release the waiting threads.");
        Console.ReadLine();
        ewh.Set();
    }

    public static void ThreadProc(object data)
    {
        int index = (int) data;

        Console.WriteLine("Thread {0} blocks.", data);
        // Increment the count of blocked threads.
        Interlocked.Increment(ref threadCount);

        // Wait on the EventWaitHandle.
        ewh.WaitOne();

        Console.WriteLine("Thread {0} exits.", data);
        // Decrement the count of blocked threads.
        Interlocked.Decrement(ref threadCount);

        // After signaling ewh, the main thread blocks on
        // clearCount until the signaled thread has 
        // decremented the count. Signal it now.
        //
        clearCount.Set();
    }
}

Imports System.Threading

Public Class Example

    ' The EventWaitHandle used to demonstrate the difference
    ' between AutoReset and ManualReset synchronization events.
    '
    Private Shared ewh As EventWaitHandle

    ' A counter to make sure all threads are started and
    ' blocked before any are released. A Long is used to show
    ' the use of the 64-bit Interlocked methods.
    '
    Private Shared threadCount As Long = 0

    ' An AutoReset event that allows the main thread to block
    ' until an exiting thread has decremented the count.
    '
    Private Shared clearCount As New EventWaitHandle(False, _
        EventResetMode.AutoReset)

    <MTAThread> _
    Public Shared Sub Main()

        ' Create an AutoReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.AutoReset)

        ' Create and start five numbered threads. Use the
        ' ParameterizedThreadStart delegate, so the thread
        ' number can be passed as an argument to the Start 
        ' method.
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        ' When multiple threads use a 64-bit value on a 32-bit
        ' system, you must access the value through the
        ' Interlocked class to guarantee thread safety.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Release one thread each time the user presses ENTER,
        ' until all threads have been released.
        '
        While Interlocked.Read(threadCount) > 0
            Console.WriteLine("Press ENTER to release a waiting thread.")
            Console.ReadLine()

            ' SignalAndWait signals the EventWaitHandle, which
            ' releases exactly one thread before resetting, 
            ' because it was created with AutoReset mode. 
            ' SignalAndWait then blocks on clearCount, to 
            ' allow the signaled thread to decrement the count
            ' before looping again.
            '
            WaitHandle.SignalAndWait(ewh, clearCount)
        End While
        Console.WriteLine()

        ' Create a ManualReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.ManualReset)

        ' Create and start five more numbered threads.
        '
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Because the EventWaitHandle was created with
        ' ManualReset mode, signaling it releases all the
        ' waiting threads.
        '
        Console.WriteLine("Press ENTER to release the waiting threads.")
        Console.ReadLine()
        ewh.Set()
        
    End Sub

    Public Shared Sub ThreadProc(ByVal data As Object)
        Dim index As Integer = CInt(data)

        Console.WriteLine("Thread {0} blocks.", data)
        ' Increment the count of blocked threads.
        Interlocked.Increment(threadCount)

        ' Wait on the EventWaitHandle.
        ewh.WaitOne()

        Console.WriteLine("Thread {0} exits.", data)
        ' Decrement the count of blocked threads.
        Interlocked.Decrement(threadCount)

        ' After signaling ewh, the main thread blocks on
        ' clearCount until the signaled thread has 
        ' decremented the count. Signal it now.
        '
        clearCount.Set()
    End Sub
End Class

Uwagi

Ta operacja nie jest gwarantowana jako niepodzielna. Po sygnałach toSignal bieżącego wątku, ale zanim zaczeka na toWaitOn, wątek uruchomiony na innym procesorze może sygnalizać toWaitOn lub poczekać na nim.

Dotyczy

SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

Źródło:: WaitHandle.cs

Źródło:: WaitHandle.cs

Źródło:: WaitHandle.cs

Sygnalizuje jeden WaitHandle i czeka na inny, określając interwał limitu czasu jako 32-bitową liczbę całkowitą podpisaną i określając, czy należy zamknąć domenę synchronizacji dla kontekstu przed wprowadzeniem oczekiwania.

public:
 static bool SignalAndWait(System::Threading::WaitHandle ^ toSignal, System::Threading::WaitHandle ^ toWaitOn, int millisecondsTimeout, bool exitContext);

public static bool SignalAndWait (System.Threading.WaitHandle toSignal, System.Threading.WaitHandle toWaitOn, int millisecondsTimeout, bool exitContext);

static member SignalAndWait : System.Threading.WaitHandle * System.Threading.WaitHandle * int * bool -> bool

Public Shared Function SignalAndWait (toSignal As WaitHandle, toWaitOn As WaitHandle, millisecondsTimeout As Integer, exitContext As Boolean) As Boolean

Parametry

toSignal: WaitHandle

Sygnał WaitHandle to.

toWaitOn: WaitHandle

Zaczekaj WaitHandle na.

millisecondsTimeout: Int32

Liczba całkowita reprezentująca interwał oczekiwania. Jeśli wartość to Infinite, czyli -1, oczekiwanie jest nieskończone.

exitContext: Boolean

true aby zamknąć domenę synchronizacji dla kontekstu przed oczekiwaniem (jeśli w zsynchronizowanym kontekście) i ponownie go później; w przeciwnym razie , false.

Zwraca

Boolean

true jeśli sygnał i oczekiwanie zakończyły się pomyślnie lub false jeśli sygnał został ukończony, ale upłynął limit czasu oczekiwania.

Wyjątki

ArgumentNullException

toSignal to null.

-lub-

toWaitOn to null.

NotSupportedException

Metoda jest wywoływana w wątku w STA stanie.

InvalidOperationException

WaitHandle Nie można zasygnalizować, ponieważ przekroczyłaby maksymalną liczbę.

ArgumentOutOfRangeException

millisecondsTimeout jest liczbą ujemną inną niż -1, która reprezentuje nieskończony limit czasu.

AbandonedMutexException

Oczekiwanie zostało zakończone, ponieważ wątek zakończył się bez zwalniania mutexu.

Uwagi

Jeśli millisecondsTimeout jest zero, metoda nie blokuje. Testuje stan toWaitOn i zwraca natychmiast.

Zamykanie kontekstu

Parametr exitContext nie ma wpływu, chyba że ta metoda jest wywoływana z wewnątrz kontekstu zarządzanego niezdefault. Kontekst zarządzany może być niezdefault, jeśli wątek znajduje się wewnątrz wywołania wystąpienia klasy pochodzącej z ContextBoundObjectklasy . Nawet jeśli obecnie wykonujesz metodę w klasie, która nie pochodzi z ContextBoundObjectklasy , na przykład String, możesz być w kontekście niezdefault, jeśli element ContextBoundObject znajduje się na stosie w bieżącej domenie aplikacji.

Gdy kod jest wykonywany w kontekście niezdefinicyjnym, określając true przyczynę exitContext zakończenia kontekstu zarządzanego niezdefault (czyli przejścia do kontekstu domyślnego) przed wykonaniem tej metody. Wątek powraca do oryginalnego kontekstu niezdefault po zakończeniu wywołania tej metody.

Zamknięcie kontekstu może być przydatne, gdy klasa powiązana z kontekstem SynchronizationAttribute ma atrybut . W takim przypadku wszystkie wywołania do składowych klasy są automatycznie synchronizowane, a domena synchronizacji to cała treść kodu dla klasy. Jeśli kod w stosie wywołań elementu członkowskiego wywołuje tę metodę i określa true dla exitContextelementu , wątek zamyka domenę synchronizacji, co umożliwia wątkowi zablokowanemu wywołanie do dowolnego elementu członkowskiego obiektu. Gdy ta metoda zostanie zwrócona, wątek, który wykonał wywołanie, musi poczekać na ponowne włączenie domeny synchronizacji.

Dotyczy

SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)

Źródło:: WaitHandle.cs

Źródło:: WaitHandle.cs

Źródło:: WaitHandle.cs

Sygnalizuje jeden WaitHandle i czeka na inny, określając interwał limitu czasu jako i TimeSpan określając, czy należy zamknąć domenę synchronizacji dla kontekstu przed wprowadzeniem oczekiwania.

public:
 static bool SignalAndWait(System::Threading::WaitHandle ^ toSignal, System::Threading::WaitHandle ^ toWaitOn, TimeSpan timeout, bool exitContext);

public static bool SignalAndWait (System.Threading.WaitHandle toSignal, System.Threading.WaitHandle toWaitOn, TimeSpan timeout, bool exitContext);

static member SignalAndWait : System.Threading.WaitHandle * System.Threading.WaitHandle * TimeSpan * bool -> bool

Public Shared Function SignalAndWait (toSignal As WaitHandle, toWaitOn As WaitHandle, timeout As TimeSpan, exitContext As Boolean) As Boolean

Parametry

toSignal: WaitHandle

Sygnał WaitHandle to.

toWaitOn: WaitHandle

Zaczekaj WaitHandle na.

timeout: TimeSpan

Element TimeSpan reprezentujący interwał oczekiwania. Jeśli wartość to -1, oczekiwanie jest nieskończone.

exitContext: Boolean

true aby zamknąć domenę synchronizacji dla kontekstu przed oczekiwaniem (jeśli w zsynchronizowanym kontekście) i ponownie go później; w przeciwnym razie , false.

Zwraca

Boolean

true jeśli sygnał i oczekiwanie zakończyły się pomyślnie lub false jeśli sygnał został ukończony, ale upłynął limit czasu oczekiwania.

Wyjątki

ArgumentNullException

toSignal to null.

-lub-

toWaitOn to null.

NotSupportedException

Metoda została wywołana w wątku w STA stanie.

InvalidOperationException

toSignal jest semaforem i ma już pełną liczbę.

ArgumentOutOfRangeException

timeout oblicza ujemną liczbę milisekund innych niż -1.

-lub-

timeout wartość jest większa niż Int32.MaxValue.

AbandonedMutexException

Oczekiwanie zostało zakończone, ponieważ wątek zakończył się bez zwalniania mutexu.

Uwagi

Wartość maksymalna to timeoutInt32.MaxValue.

Jeśli timeout jest zero, metoda nie blokuje. Testuje stan toWaitOn i zwraca natychmiast.

Zamykanie kontekstu

Dotyczy

Udostępnij za pośrednictwem

WaitHandle.SignalAndWait Metoda

Definicja

Przeciążenia

SignalAndWait(WaitHandle, WaitHandle)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Dotyczy

SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

Parametry

Zwraca

Wyjątki

Uwagi

Zamykanie kontekstu

Dotyczy

SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)

Parametry

Zwraca

Wyjątki

Uwagi

Zamykanie kontekstu

Dotyczy

Dodatkowe zasoby