WaitHandle.WaitOne Yöntem

  • Başvuru

Tanım

Ad Alanı:
System.Threading
Bütünleştirilmiş Kod:
System.Runtime.dll
Bütünleştirilmiş Kod:
mscorlib.dll
Bütünleştirilmiş Kod:
netstandard.dll

Geçerli bir sinyal alıncaya kadar geçerli WaitHandle iş parçacığını engeller.

Aşırı Yüklemeler

WaitOne()

Geçerli iş parçacığını, geçerli WaitHandle bir sinyal alıncaya kadar engeller.
WaitOne(Int32)

Geçerli iş parçacığı, milisaniye WaitHandle cinsinden zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir sinyal alana kadar geçerli iş parçacığını engeller.
WaitOne(TimeSpan)

Geçerli örnek bir sinyal alıncaya kadar geçerli iş parçacığını engeller ve zaman aralığını belirtmek için bir TimeSpan kullanılır.
WaitOne(Int32, Boolean)

Geçerli iş parçacığını, zaman WaitHandle aralığını belirtmek ve beklemeden önce eşitleme etki alanından çıkıp çıkılmayacağını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir sinyal alana kadar geçerli iş parçacığını engeller.
WaitOne(TimeSpan, Boolean)

Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller; zaman aralığını belirtmek için kullanarak TimeSpan ve beklemeden önce eşitleme etki alanından çıkıp çıkılmayacağını belirtir.

WaitOne()

Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs

Geçerli iş parçacığını, geçerli WaitHandle bir sinyal alıncaya kadar engeller.

public:
 virtual bool WaitOne();
public virtual bool WaitOne ();
abstract member WaitOne : unit -> bool
override this.WaitOne : unit -> bool
Public Overridable Function WaitOne () As Boolean

Döndürülenler

Boolean

true geçerli örnek bir sinyal alırsa. Geçerli örneğe hiçbir zaman sinyal verirseniz WaitOne() hiçbir zaman döndürmez.

Özel durumlar

ObjectDisposedException

Geçerli örnek zaten atılmış.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme tamamlandı.

InvalidOperationException

Geçerli örnek, başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucudur.

Örnekler

Aşağıdaki kod örneği, bir arka plan iş parçacığının yürütmeyi bitirmesini beklerken bir işlemin sona ermesini sağlamak için bekleme tutamacını kullanmayı gösterir.

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

Açıklamalar

AbandonedMutexException.NET Framework sürüm 2.0'da yenidir. Önceki sürümlerde yöntem, WaitOne bir mutex bırakıldığında döndürür true . Terk edilmiş bir mutex genellikle ciddi bir kodlama hatasına işaret eder. Sistem genelinde bir mutex söz konusu olduğunda, bir uygulamanın aniden sonlandırıldığını gösterebilir (örneğin, Windows Görev Yöneticisi kullanılarak). Özel durum, hata ayıklama için yararlı bilgiler içerir.

Bu yöntemin çağıranı, geçerli örnek bir sinyal alana kadar süresiz olarak engeller. Başka bir WaitHandle iş parçacığından sinyal alana kadar engellemek için bu yöntemi kullanın; örneğin, zaman uyumsuz bir işlem tamamlandığında oluşturulur. Daha fazla bilgi için bkz IAsyncResult . arabirim.

Bu yöntem aşırı yüklemesini çağırmak, yöntem aşırı yüklemesini WaitOne(Int32, Boolean) çağırmak ve -1 veya Timeout.Infinite ilk parametre ve false ikinci parametre için belirtmekle eşdeğerdir.

Türetilmiş sınıfların davranışını özelleştirmek için bu yöntemi geçersiz kılın.

Şunlara uygulanır

WaitOne(Int32)

Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs

Geçerli iş parçacığı, milisaniye WaitHandle cinsinden zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir sinyal alana kadar geçerli iş parçacığını engeller.

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

Parametreler

millisecondsTimeout
Int32

Beklenen milisaniye sayısı veya Infinite (-1) süresiz olarak bekleniyor.

Döndürülenler

Boolean

true geçerli örnek bir sinyal alırsa; aksi takdirde , false.

Özel durumlar

ObjectDisposedException

Geçerli örnek zaten atılmış.

ArgumentOutOfRangeException

millisecondsTimeout , -1 dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme tamamlandı.

InvalidOperationException

Geçerli örnek, başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucudur.

Örnekler

Aşağıdaki kod örneği, bir arka plan iş parçacığının yürütmeyi bitirmesini beklerken bir işlemin sona ermesini sağlamak için bekleme tutamacını kullanmayı gösterir.

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

Açıklamalar

Sıfır ise millisecondsTimeout , yöntemi engellemez. Bekleme tutamacının durumunu test eder ve hemen döndürür.

Bu yöntemin çağıranı, geçerli örnek bir sinyal alana veya zaman aşımı oluşana kadar engeller. Başka bir WaitHandle iş parçacığından sinyal alana kadar engellemek için bu yöntemi kullanın; örneğin, zaman uyumsuz bir işlem tamamlandığında oluşturulur. Daha fazla bilgi için bkz IAsyncResult . arabirim.

Türetilmiş sınıfların davranışını özelleştirmek için bu yöntemi geçersiz kılın.

Bu yöntem aşırı yüklemesini çağırmak, aşırı yüklemeyi çağırmak WaitOne(Int32, Boolean) ve için belirtmekle falseexitContextaynıdır.

Şunlara uygulanır

WaitOne(TimeSpan)

Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs

Geçerli örnek bir sinyal alıncaya kadar geçerli iş parçacığını engeller ve zaman aralığını belirtmek için bir TimeSpan kullanılır.

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

Parametreler

timeout
TimeSpan

TimeSpan Bekleyebilecek milisaniye sayısını temsil eden veya süresiz olarak bekleyebilecek -1 milisaniyeyi temsil eden birTimeSpan.

Döndürülenler

Boolean

true geçerli örnek bir sinyal alırsa; aksi takdirde , false.

Özel durumlar

ObjectDisposedException

Geçerli örnek zaten atılmış.

ArgumentOutOfRangeException

timeout , -1 milisaniye dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

-veya-

timeout Int32.MaxValue değerinden büyüktür.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme tamamlandı.

InvalidOperationException

Geçerli örnek, başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucudur.

Açıklamalar

Sıfır ise timeout , yöntemi engellemez. Bekleme tutamacının durumunu test eder ve hemen döndürür.

Bu yöntemin çağıranı, geçerli örnek bir sinyal alana veya zaman aşımı oluşana kadar engeller. Başka bir WaitHandle iş parçacığından sinyal alana kadar engellemek için bu yöntemi kullanın; örneğin, zaman uyumsuz bir işlem tamamlandığında oluşturulur. Daha fazla bilgi için bkz IAsyncResult . arabirim.

Türetilmiş sınıfların davranışını özelleştirmek için bu yöntemi geçersiz kılın.

için timeout en büyük değer değeridir Int32.MaxValue.

Bu yöntem aşırı yüklemesini çağırmak, aşırı yüklemeyi çağırmak WaitOne(TimeSpan, Boolean) ve için belirtmekle falseexitContextaynıdır.

Şunlara uygulanır

WaitOne(Int32, Boolean)

Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs

Geçerli iş parçacığını, zaman WaitHandle aralığını belirtmek ve beklemeden önce eşitleme etki alanından çıkıp çıkılmayacağını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir sinyal alana kadar geçerli iş parçacığını engeller.

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

Parametreler

millisecondsTimeout
Int32

Beklenen milisaniye sayısı veya Infinite (-1) süresiz olarak bekleniyor.

exitContext
Boolean

true beklemeden önce bağlam için eşitleme etki alanından çıkmak (eşitlenmiş bir bağlamdaysa) ve daha sonra yeniden almak; aksi takdirde , false.

Döndürülenler

Boolean

true geçerli örnek bir sinyal alırsa; aksi takdirde , false.

Özel durumlar

ObjectDisposedException

Geçerli örnek zaten atılmış.

ArgumentOutOfRangeException

millisecondsTimeout , -1 dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme tamamlandı.

InvalidOperationException

Geçerli örnek, başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucudur.

Örnekler

Aşağıdaki örnek, bir eşitleme etki alanı içinde çağrıldığında yöntemin aşırı yüklemesinin nasıl WaitOne(Int32, Boolean) davrandığını gösterir. İlk olarak, bir iş parçacığı bekleme zaman aşımı süresi dolana kadar olarak ayarlanmış false ve bloklarla exitContext bekler. İlk iş parçacığı sonlandırıldıktan ve exitContext olarak ayarlandıktan truesonra ikinci bir iş parçacığı yürütülür. Bu ikinci iş parçacığının bekleme tutamacını işaret etmeye yönelik çağrı engellenmez ve iş parçacığı bekleme zaman aşımından önce tamamlanır.

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!!!

Açıklamalar

Sıfır ise millisecondsTimeout , yöntemi engellemez. Bekleme tutamacının durumunu test eder ve hemen döndürür.

Bir mutex terk edilirse, bir AbandonedMutexException atılır. Terk edilmiş bir mutex genellikle ciddi bir kodlama hatasına işaret eder. Sistem genelinde bir mutex söz konusu olduğunda, bir uygulamanın aniden sonlandırıldığını gösterebilir (örneğin, Windows Görev Yöneticisi kullanılarak). Özel durum, hata ayıklama için yararlı bilgiler içerir.

Bu yöntemin çağıranı, geçerli örnek bir sinyal alana veya zaman aşımı oluşana kadar engeller. Başka bir WaitHandle iş parçacığından sinyal alana kadar engellemek için bu yöntemi kullanın; örneğin, zaman uyumsuz bir işlem tamamlandığında oluşturulur. Daha fazla bilgi için bkz IAsyncResult . arabirim.

Türetilmiş sınıfların davranışını özelleştirmek için bu yöntemi geçersiz kılın.

Bağlamdan çıkma

Bu exitContext yöntem, bilinmeyen yönetilen bağlamın içinden çağrılmadığı sürece parametresinin hiçbir etkisi olmaz. İş parçacığınız öğesinden ContextBoundObjecttüretilen bir sınıfın örneğine yönelik bir çağrının içindeyse yönetilen bağlamda hiçbir zaman uyumsuz olabilir. şu anda gibi Stringöğesinden ContextBoundObjecttüretilmiş olmayan bir sınıfta bir yöntem yürütüyor olsanız bile, geçerli uygulama etki alanındaki yığınınızda bir varsaContextBoundObject, varsayılan olmayan bir bağlamda olabilirsiniz.

Kodunuz bilinmeyen bir bağlamda yürütülürken öğesinin belirtilmesi trueexitContext , iş parçacığının bu yöntemi yürütmeden önce bilinmeyen yönetilen bağlamdan (varsayılan bağlama geçiş için) çıkmasını sağlar. İş parçacığı, bu yöntem çağrısı tamamlandıktan sonra özgün bilinmeyen bağlama döner.

Bağlama bağlı sınıf özniteliğine sahip olduğunda bağlamdan SynchronizationAttribute çıkmak yararlı olabilir. Bu durumda, sınıfın üyelerine yapılan tüm çağrılar otomatik olarak eşitlenir ve eşitleme etki alanı sınıfın kod gövdesinin tamamıdır. Bir üyenin çağrı yığınındaki kod bu yöntemi çağırır ve öğesini exitContextbelirtirsetrue, iş parçacığı eşitleme etki alanından çıkar ve bu da nesnenin herhangi bir üyesine yapılan çağrıda engellenen bir iş parçacığının devam etmesini sağlar. Bu yöntem döndürdüğünde, çağrıyı yapan iş parçacığının eşitleme etki alanını yeniden eklemek için beklemesi gerekir.

Şunlara uygulanır

WaitOne(TimeSpan, Boolean)

Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs
Kaynak:
WaitHandle.cs

Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller; zaman aralığını belirtmek için bir TimeSpan kullanın ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtin.

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

Parametreler

timeout
TimeSpan

TimeSpan Beklenen milisaniye sayısını temsil eden veya süresiz olarak bekleyebilecek -1 milisaniyeyi temsil eden birTimeSpan.

exitContext
Boolean

true beklemeden önce bağlam için eşitleme etki alanından çıkmak (eşitlenmiş bir bağlamdaysa) ve daha sonra yeniden almak için; aksi takdirde , false.

Döndürülenler

Boolean

true geçerli örnek bir sinyal alırsa; aksi takdirde , false.

Özel durumlar

ObjectDisposedException

Geçerli örnek zaten atılmış.

ArgumentOutOfRangeException

timeout , -1 milisaniye dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

-veya-

timeout Int32.MaxValue değerinden büyüktür.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme tamamlandı.

InvalidOperationException

Geçerli örnek, başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucudur.

Örnekler

Aşağıdaki kod örneği, bir arka plan iş parçacığının yürütmeyi bitirmesini beklerken bir işlemin sona ermesini sağlamak için bekleme tutamacını kullanmayı gösterir.

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

Açıklamalar

Sıfır ise timeout , yöntemi engellemez. Bekleme tutamacının durumunu test eder ve hemen döndürür.

Bir mutex terk edilirse, bir AbandonedMutexException atılır. Terk edilmiş bir mutex genellikle ciddi bir kodlama hatasına işaret eder. Sistem genelinde bir mutex söz konusu olduğunda, bir uygulamanın aniden sonlandırıldığını gösterebilir (örneğin, Windows Görev Yöneticisi kullanılarak). Özel durum, hata ayıklama için yararlı bilgiler içerir.

Bu yöntemin çağıranı, geçerli örnek bir sinyal alıncaya veya zaman aşımı oluşana kadar engeller. Bir başka iş parçacığından sinyal alıncaya kadar WaitHandle engellemek için bu yöntemi kullanın; örneğin, zaman uyumsuz bir işlem tamamlandığında oluşturulur. Daha fazla bilgi için bkz IAsyncResult . arabirim.

Türetilmiş sınıfların davranışını özelleştirmek için bu yöntemi geçersiz kılın.

için timeout en büyük değer: Int32.MaxValue.

Bağlamdan çıkma

Bu exitContext yöntem, bilinmeyen yönetilen bağlamın içinden çağrılmadığı sürece parametresinin hiçbir etkisi olmaz. İş parçacığınız öğesinden ContextBoundObjecttüretilen bir sınıfın örneğine yönelik bir çağrının içindeyse yönetilen bağlam varsayılan olmayabilir. Şu anda gibi öğesinden ContextBoundObjectStringtüretilmemiş bir sınıfta bir yöntem yürütüyor olsanız bile, geçerli uygulama etki alanındaki yığınınızda bir varsaContextBoundObject, farklı bir bağlamda olabilirsiniz.

Kodunuz varsayılan olmayan bir bağlamda yürütülürken, öğesinin exitContext belirtilmesitrue, iş parçacığının bu yöntemi yürütmeden önce varsayılan bağlama geçiş için varsayılan olmayan yönetilen bağlamdan (varsayılan bağlama geçiş) çıkmasına neden olur. İş parçacığı, bu yönteme yapılan çağrı tamamlandıktan sonra özgün varsayılan olmayan bağlama döner.

Bağlama bağlı sınıf özniteliğine sahip olduğunda bağlamdan SynchronizationAttribute çıkmak yararlı olabilir. Bu durumda, sınıfın üyelerine yapılan tüm çağrılar otomatik olarak eşitlenir ve eşitleme etki alanı sınıfın kod gövdesinin tamamıdır. Bir üyenin çağrı yığınındaki kod bu yöntemi çağırır ve için exitContextbelirtirsetrue, iş parçacığı eşitleme etki alanından çıkar ve bu da nesnenin herhangi bir üyesine yapılan çağrıda engellenen bir iş parçacığının devam etmesini sağlar. Bu yöntem döndürdüğünde, eşitleme etki alanını yeniden eklemek için çağrıyı yapan iş parçacığının beklemesi gerekir.

Şunlara uygulanır