WaitHandle.WaitOne Metoda

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

public:
 virtual bool WaitOne();

public virtual bool WaitOne ();

abstract member WaitOne : unit -> bool
override this.WaitOne : unit -> bool

Public Overridable Function WaitOne () As Boolean

Návraty

true pokud aktuální instance obdrží signál. Pokud aktuální instance není nikdy signalizovat, WaitOne() nikdy nevrátí.

Výjimky

Příklady

Následující příklad kódu ukazuje, jak použít obslužnou rutinu čekání, aby se proces nepřekončil, zatímco čeká na dokončení provádění vlákna na pozadí.

using namespace System;
using namespace System::Threading;
ref class WaitOne
{
private:
   WaitOne(){}


public:
   static void WorkMethod( Object^ stateInfo )
   {
      Console::WriteLine( "Work starting." );
      
      // Simulate time spent working.
      Thread::Sleep( (gcnew Random)->Next( 100, 2000 ) );
      
      // Signal that work is finished.
      Console::WriteLine( "Work ending." );
      dynamic_cast<AutoResetEvent^>(stateInfo)->Set();
   }

};

int main()
{
   Console::WriteLine( "Main starting." );
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &WaitOne::WorkMethod ), autoEvent );
   
   // Wait for work method to signal.
   autoEvent->WaitOne(  );
   Console::WriteLine( "Work method signaled.\nMain ending." );
}

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        autoEvent.WaitOne();
        Console.WriteLine("Work method signaled.\nMain ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        autoEvent.WaitOne()
        Console.WriteLine("Work method signaled.")
        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Poznámky

AbandonedMutexException je novinka v rozhraní .NET Framework verze 2.0. V předchozích verzích WaitOne metoda vrací true hodnotu, když dojde k opuštění mutexu. Opuštěný mutex často značí závažnou chybu kódování. V případě systémového mutexu to může znamenat, že aplikace byla náhle ukončena (například pomocí Správce úloh systému Windows). Výjimka obsahuje informace užitečné pro ladění.

Volající této metody blokuje po neomezenou dobu, dokud aktuální instance neobdrží signál. Tuto metodu použijte k blokování, dokud WaitHandle neobdrží signál z jiného vlákna, například je generován při dokončení asynchronní operace. Další informace najdete v IAsyncResult rozhraní .

Volání přetížení této metody je ekvivalentní volání WaitOne(Int32, Boolean) přetížení metody a zadání -1 nebo Timeout.Infinite pro první parametr a false druhý parametr.

Přepsat tuto metodu přizpůsobit chování odvozených tříd.

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

public:
 virtual bool WaitOne(int millisecondsTimeout);

public virtual bool WaitOne (int millisecondsTimeout);

abstract member WaitOne : int -> bool
override this.WaitOne : int -> bool

Public Overridable Function WaitOne (millisecondsTimeout As Integer) As Boolean

Parametry

Návraty

truepokud aktuální instance obdrží signál; v opačném případě . false

Výjimky

Příklady

Následující příklad kódu ukazuje, jak použít obslužnou rutinu čekání, aby se proces nepřekončil, zatímco čeká na dokončení provádění vlákna na pozadí.

using namespace System;
using namespace System::Threading;
ref class WaitOne
{
private:
   WaitOne(){}


public:
   static void WorkMethod( Object^ stateInfo )
   {
      Console::WriteLine( "Work starting." );
      
      // Simulate time spent working.
      Thread::Sleep( (gcnew Random)->Next( 100, 2000 ) );
      
      // Signal that work is finished.
      Console::WriteLine( "Work ending." );
      dynamic_cast<AutoResetEvent^>(stateInfo)->Set();
   }

};

int main()
{
   Console::WriteLine( "Main starting." );
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &WaitOne::WorkMethod ), autoEvent );
   
   // Wait for work method to signal.
   if ( autoEvent->WaitOne( 1000 ) )
   {
      Console::WriteLine( "Work method signaled." );
   }
   else
   {
      Console::WriteLine( "Timed out waiting for work "
      "method to signal." );
   }

   Console::WriteLine( "Main ending." );
}

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(1000))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(1000) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Poznámky

Pokud millisecondsTimeout je nula, metoda neblokuje. Otestuje stav obslužného rutiny čekání a okamžitě se vrátí.

Volající této metody blokuje, dokud aktuální instance neobdrží signál nebo dojde k vypršení časového limitu. Tuto metodu použijte k blokování, dokud WaitHandle neobdrží signál z jiného vlákna, například je generován při dokončení asynchronní operace. Další informace najdete v IAsyncResult rozhraní .

Přepsat tuto metodu přizpůsobit chování odvozených tříd.

Volání přetížení této metody je stejné jako volání WaitOne(Int32, Boolean) přetížení a zadání false pro exitContext.

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

public:
 virtual bool WaitOne(TimeSpan timeout);

public virtual bool WaitOne (TimeSpan timeout);

abstract member WaitOne : TimeSpan -> bool
override this.WaitOne : TimeSpan -> bool

Public Overridable Function WaitOne (timeout As TimeSpan) As Boolean

Parametry

Návraty

truepokud aktuální instance obdrží signál; v opačném případě . false

Výjimky

Poznámky

Pokud timeout je nula, metoda neblokuje. Otestuje stav obslužného rutiny čekání a okamžitě se vrátí.

Volající této metody blokuje, dokud aktuální instance neobdrží signál nebo dojde k vypršení časového limitu. Tuto metodu použijte k blokování, dokud WaitHandle neobdrží signál z jiného vlákna, například je generován při dokončení asynchronní operace. Další informace najdete v IAsyncResult rozhraní .

Přepsat tuto metodu přizpůsobit chování odvozených tříd.

Maximální hodnota pro timeout je Int32.MaxValue.

Volání přetížení této metody je stejné jako volání WaitOne(TimeSpan, Boolean) přetížení a zadání false pro exitContext.

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

public:
 virtual bool WaitOne(int millisecondsTimeout, bool exitContext);

public virtual bool WaitOne (int millisecondsTimeout, bool exitContext);

abstract member WaitOne : int * bool -> bool
override this.WaitOne : int * bool -> bool

Public Overridable Function WaitOne (millisecondsTimeout As Integer, exitContext As Boolean) As Boolean

Parametry

Návraty

truepokud aktuální instance obdrží signál; v opačném případě . false

Výjimky

Příklady

Následující příklad ukazuje, jak WaitOne(Int32, Boolean) se přetížení metody chová, když je volána v rámci synchronizační domény. Nejprve vlákno čeká s nastaveným exitContext a bloky, false dokud nevyprší časový limit čekání. Druhé vlákno se spustí poté, co se první vlákno ukončí a počká s nastavenou exitContext na truehodnotu . Volání signalizovat čekání popisovač pro toto druhé vlákno není blokována a vlákno se dokončí před vypršením časového limitu čekání.

using namespace System;
using namespace System::Threading;
using namespace System::Runtime::Remoting::Contexts;

[Synchronization(true)]
public ref class SyncingClass : ContextBoundObject
{
private:
    EventWaitHandle^ waitHandle;

public:
    SyncingClass()
    {
         waitHandle =
            gcnew EventWaitHandle(false, EventResetMode::ManualReset);
    }

    void Signal()
    {
        Console::WriteLine("Thread[{0:d4}]: Signalling...", Thread::CurrentThread->GetHashCode());
        waitHandle->Set();
    }

    void DoWait(bool leaveContext)
    {
        bool signalled;

        waitHandle->Reset();
        Console::WriteLine("Thread[{0:d4}]: Waiting...", Thread::CurrentThread->GetHashCode());
        signalled = waitHandle->WaitOne(3000, leaveContext);
        if (signalled)
        {
            Console::WriteLine("Thread[{0:d4}]: Wait released!!!", Thread::CurrentThread->GetHashCode());
        }
        else
        {
            Console::WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread::CurrentThread->GetHashCode());
        }
    }
};

public ref class TestSyncDomainWait
{
public:
    static void Main()
    {
        SyncingClass^ syncClass = gcnew SyncingClass();

        Thread^ runWaiter;

        Console::WriteLine("\nWait and signal INSIDE synchronization domain:\n");
        runWaiter = gcnew Thread(gcnew ParameterizedThreadStart(&TestSyncDomainWait::RunWaitKeepContext));
        runWaiter->Start(syncClass);
        Thread::Sleep(1000);
        Console::WriteLine("Thread[{0:d4}]: Signal...", Thread::CurrentThread->GetHashCode());
        // This call to Signal will block until the timeout in DoWait expires.
        syncClass->Signal();
        runWaiter->Join();

        Console::WriteLine("\nWait and signal OUTSIDE synchronization domain:\n");
        runWaiter = gcnew Thread(gcnew ParameterizedThreadStart(&TestSyncDomainWait::RunWaitLeaveContext));
        runWaiter->Start(syncClass);
        Thread::Sleep(1000);
        Console::WriteLine("Thread[{0:d4}]: Signal...", Thread::CurrentThread->GetHashCode());
        // This call to Signal is unblocked and will set the wait handle to
        // release the waiting thread.
        syncClass->Signal();
        runWaiter->Join();
    }

    static void RunWaitKeepContext(Object^ parm)
    {
        ((SyncingClass^)parm)->DoWait(false);
    }

    static void RunWaitLeaveContext(Object^ parm)
    {
        ((SyncingClass^)parm)->DoWait(true);
    }
};

int main()
{
    TestSyncDomainWait::Main();
}
// The output for the example program will be similar to the following:
//
// Wait and signal INSIDE synchronization domain:
//
// Thread[0004]: Waiting...
// Thread[0001]: Signal...
// Thread[0004]: Wait timeout!!!
// Thread[0001]: Signalling...
//
// Wait and signal OUTSIDE synchronization domain:
//
// Thread[0006]: Waiting...
// Thread[0001]: Signal...
// Thread[0001]: Signalling...
// Thread[0006]: Wait released!!!

using System;
using System.Threading;
using System.Runtime.Remoting.Contexts;

[Synchronization(true)]
public class SyncingClass : ContextBoundObject
{
    private EventWaitHandle waitHandle;

    public SyncingClass()
    {
         waitHandle =
            new EventWaitHandle(false, EventResetMode.ManualReset);
    }

    public void Signal()
    {
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode());
        waitHandle.Set();
    }

    public void DoWait(bool leaveContext)
    {
        bool signalled;

        waitHandle.Reset();
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode());
        signalled = waitHandle.WaitOne(3000, leaveContext);
        if (signalled)
        {
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode());
        }
        else
        {
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode());
        }
    }
}

public class TestSyncDomainWait
{
    public static void Main()
    {
        SyncingClass syncClass = new SyncingClass();

        Thread runWaiter;

        Console.WriteLine("\nWait and signal INSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitKeepContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal();
        runWaiter.Join();

        Console.WriteLine("\nWait and signal OUTSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitLeaveContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal is unblocked and will set the wait handle to
        // release the waiting thread.
        syncClass.Signal();
        runWaiter.Join();
    }

    public static void RunWaitKeepContext(object parm)
    {
        ((SyncingClass)parm).DoWait(false);
    }

    public static void RunWaitLeaveContext(object parm)
    {
        ((SyncingClass)parm).DoWait(true);
    }
}

// The output for the example program will be similar to the following:
//
// Wait and signal INSIDE synchronization domain:
//
// Thread[0004]: Waiting...
// Thread[0001]: Signal...
// Thread[0004]: Wait timeout!!!
// Thread[0001]: Signalling...
//
// Wait and signal OUTSIDE synchronization domain:
//
// Thread[0006]: Waiting...
// Thread[0001]: Signal...
// Thread[0001]: Signalling...
// Thread[0006]: Wait released!!!

Imports System.Threading
Imports System.Runtime.Remoting.Contexts

<Synchronization(true)>
Public Class SyncingClass
    Inherits ContextBoundObject
    
    Private waitHandle As EventWaitHandle

    Public Sub New()
         waitHandle = New EventWaitHandle(false, EventResetMode.ManualReset)
    End Sub

    Public Sub Signal()
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode())
        waitHandle.Set()
    End Sub

    Public Sub DoWait(leaveContext As Boolean)
        Dim signalled As Boolean

        waitHandle.Reset()
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode())
        signalled = waitHandle.WaitOne(3000, leaveContext)
        If signalled Then
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode())
        Else
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode())
        End If
    End Sub
End Class

Public Class TestSyncDomainWait
    Public Shared Sub Main()
        Dim syncClass As New SyncingClass()

        Dim runWaiter As Thread

        Console.WriteLine(Environment.NewLine + "Wait and signal INSIDE synchronization domain:" + Environment.NewLine)
        runWaiter = New Thread(AddressOf RunWaitKeepContext)
        runWaiter.Start(syncClass)
        Thread.Sleep(1000)
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode())
        ' This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal()
        runWaiter.Join()

        Console.WriteLine(Environment.NewLine + "Wait and signal OUTSIDE synchronization domain:" + Environment.NewLine)
        runWaiter = New Thread(AddressOf RunWaitLeaveContext)
        runWaiter.Start(syncClass)
        Thread.Sleep(1000)
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode())
        ' This call to Signal is unblocked and will set the wait handle to
        ' release the waiting thread.
        syncClass.Signal()
        runWaiter.Join()
    End Sub

    Public Shared Sub RunWaitKeepContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(False)
    End Sub

    Public Shared Sub RunWaitLeaveContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(True)
    End Sub
End Class

' The output for the example program will be similar to the following:
'
' Wait and signal INSIDE synchronization domain:
'
' Thread[0004]: Waiting...
' Thread[0001]: Signal...
' Thread[0004]: Wait timeout!!!
' Thread[0001]: Signalling...
'
' Wait and signal OUTSIDE synchronization domain:
'
' Thread[0006]: Waiting...
' Thread[0001]: Signal...
' Thread[0001]: Signalling...
' Thread[0006]: Wait released!!!

Poznámky

Pokud millisecondsTimeout je nula, metoda neblokuje. Otestuje stav obslužného rutiny čekání a okamžitě se vrátí.

Pokud dojde k opuštění mutexu, AbandonedMutexException vyvolá se chyba . Opuštěný mutex často značí závažnou chybu kódování. V případě systémového mutexu to může znamenat, že aplikace byla náhle ukončena (například pomocí Správce úloh systému Windows). Výjimka obsahuje informace užitečné pro ladění.

Volající této metody blokuje, dokud aktuální instance neobdrží signál nebo dojde k vypršení časového limitu. Tuto metodu použijte k blokování, dokud WaitHandle neobdrží signál z jiného vlákna, například je generován při dokončení asynchronní operace. Další informace najdete v IAsyncResult rozhraní .

Přepsat tuto metodu přizpůsobit chování odvozených tříd.

Ukončení kontextu

Parametr exitContext nemá žádný vliv, pokud tato metoda není volána z nevýkonných spravovaných kontextů. Spravovaný kontext může být nevýchozí, pokud se vlákno nachází uvnitř volání instance třídy odvozené z ContextBoundObject. I když aktuálně spouštíte metodu pro třídu, která není odvozená z ContextBoundObject, jako Stringje , můžete být v nevýchozím kontextu, pokud je ve vašem zásobníku ContextBoundObject v aktuální doméně aplikace.

Když se váš kód spouští v nevýchozím kontextu, určení true for exitContext způsobí, že vlákno ukončí nevýchozí spravovaný kontext (tj. pro přechod do výchozího kontextu) před spuštěním této metody. Vlákno se po dokončení volání této metody vrátí k původnímu nevýchozí kontext.

Ukončení kontextu může být užitečné, pokud kontextová třída má SynchronizationAttribute atribut . V takovém případě jsou všechna volání členů třídy automaticky synchronizována a doména synchronizace je celé tělo kódu pro třídu. Pokud kód v zásobníku volání člena volá tuto metodu a určuje true pro exitContext, vlákno opustí synchronizační doménu, což umožňuje vlákno blokované při volání libovolného člena objektu pokračovat. Když tato metoda vrátí, vlákno, které provedlo volání, musí počkat na opětovné zadání synchronizační domény.

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

Zdroj:

WaitHandle.cs

public:
 virtual bool WaitOne(TimeSpan timeout, bool exitContext);

public virtual bool WaitOne (TimeSpan timeout, bool exitContext);

abstract member WaitOne : TimeSpan * bool -> bool
override this.WaitOne : TimeSpan * bool -> bool

Public Overridable Function WaitOne (timeout As TimeSpan, exitContext As Boolean) As Boolean

Parametry

Návraty

truepokud aktuální instance obdrží signál; v opačném případě . false

Výjimky

Příklady

Následující příklad kódu ukazuje, jak použít obslužnou rutinu čekání, aby se proces nepřekončil, zatímco čeká na dokončení provádění vlákna na pozadí.

using namespace System;
using namespace System::Threading;
ref class WaitOne
{
private:
   WaitOne(){}


public:
   static void WorkMethod( Object^ stateInfo )
   {
      Console::WriteLine( "Work starting." );
      
      // Simulate time spent working.
      Thread::Sleep( (gcnew Random)->Next( 100, 2000 ) );
      
      // Signal that work is finished.
      Console::WriteLine( "Work ending." );
      dynamic_cast<AutoResetEvent^>(stateInfo)->Set();
   }

};

int main()
{
   Console::WriteLine( "Main starting." );
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &WaitOne::WorkMethod ), autoEvent );
   
   // Wait for work method to signal.
   if ( autoEvent->WaitOne( TimeSpan(0,0,1), false ) )
   {
      Console::WriteLine( "Work method signaled." );
   }
   else
   {
      Console::WriteLine( "Timed out waiting for work "
      "method to signal." );
   }

   Console::WriteLine( "Main ending." );
}

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(new TimeSpan(0, 0, 1), false))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(New TimeSpan(0, 0, 1), False) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Poznámky

Pokud timeout je nula, metoda neblokuje. Otestuje stav popisovače čekání a okamžitě se vrátí.

Pokud je mutex opuštěn, AbandonedMutexException je vyvolán. Opuštěný mutex často značí závažnou chybu kódování. V případě systémového mutexu to může znamenat, že aplikace byla náhle ukončena (například pomocí Správce úloh systému Windows). Výjimka obsahuje informace užitečné pro ladění.

Volající této metody blokuje, dokud aktuální instance přijme signál nebo dojde k vypršení časového limitu. Tuto metodu WaitHandle použijte k blokování, dokud objekt neobdrží signál z jiného vlákna, například při dokončení asynchronní operace. Další informace najdete v IAsyncResult rozhraní.

Přepište tuto metodu pro přizpůsobení chování odvozených tříd.

Maximální hodnota pro timeout je Int32.MaxValue.

Ukončení kontextu

Parametr exitContext nemá žádný vliv, pokud tato metoda není volána z nedefault spravovaného kontextu. Spravovaný kontext může být nedefault, pokud se vlákno nachází uvnitř volání instance třídy odvozené z ContextBoundObject. I když právě provádíte metodu ve třídě, která není odvozená z ContextBoundObject, jako Stringje , můžete být v nestandardním kontextu, pokud je ve vašem zásobníku ContextBoundObject v aktuální doméně aplikace.

Když se váš kód spouští v nedefaultním kontextu, zadání true pro exitContext způsobí, že vlákno ukončí nedefaultní spravovaný kontext (to znamená přechod do výchozího kontextu) před spuštěním této metody. Vlákno se vrátí do původního nedefault kontextu po volání této metody dokončí.

Ukončení kontextu může být užitečné, pokud třída vázaná na kontext má SynchronizationAttribute atribut. V takovém případě jsou všechna volání členů třídy automaticky synchronizována a doména synchronizace je celé tělo kódu pro třídu. Pokud kód v zásobníku volání člena volá tuto metodu a určuje true pro exitContext, vlákno ukončí synchronizační doménu, což umožňuje pokračovat vlákno blokované při volání libovolného člena objektu. Když tato metoda vrátí, vlákno, které provedlo volání, musí počkat na opětovné zadání synchronizační domény.