WaitHandle.WaitOne Metode

  • Referensi

Definisi

Ruang nama:
System.Threading
Rakitan:
System.Runtime.dll
Rakitan:
mscorlib.dll
Rakitan:
netstandard.dll

Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal.

Overload

WaitOne()

Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal.
WaitOne(Int32)

Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal, menggunakan bilangan bulat bertanda tangan 32-bit untuk menentukan interval waktu dalam milidetik.
WaitOne(TimeSpan)

Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu.
WaitOne(Int32, Boolean)

Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal, menggunakan bilangan bulat bertanda tangan 32-bit untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu.
WaitOne(TimeSpan, Boolean)

Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu.

WaitOne()

Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs

Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal.

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

Mengembalikan

Boolean

true jika instans saat ini menerima sinyal. Jika instans saat ini tidak pernah diberi sinyal, WaitOne() tidak pernah kembali.

Pengecualian

ObjectDisposedException

Instans saat ini telah dibuang.

AbandonedMutexException

Penantian selesai karena utas keluar tanpa melepaskan mutex.

InvalidOperationException

Instans saat ini adalah proksi transparan untuk WaitHandle di domain aplikasi lain.

Contoh

Contoh kode berikut menunjukkan cara menggunakan handel tunggu untuk menjaga agar proses tidak berakhir saat menunggu utas latar belakang selesai dieksekusi.

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

Keterangan

AbandonedMutexExceptionbaru dalam .NET Framework versi 2.0. Di versi sebelumnya, WaitOne metode akan kembali true saat mutex ditinggalkan. Mutex yang ditinggalkan sering menunjukkan kesalahan pengkodian yang serius. Dalam kasus mutex di seluruh sistem, mungkin menunjukkan bahwa aplikasi telah dihentikan tiba-tiba (misalnya, dengan menggunakan Windows Task Manager). Pengecualian berisi informasi yang berguna untuk penelusuran kesalahan.

Pemanggil metode ini memblokir tanpa batas waktu sampai instans saat ini menerima sinyal. Gunakan metode ini untuk memblokir hingga WaitHandle menerima sinyal dari utas lain, seperti dihasilkan ketika operasi asinkron selesai. Untuk informasi selengkapnya, lihat IAsyncResult antarmuka.

Memanggil metode ini kelebihan beban setara dengan memanggil WaitOne(Int32, Boolean) metode kelebihan beban dan menentukan -1 atau Timeout.Infinite untuk parameter pertama dan false untuk parameter kedua.

Ambil alih metode ini untuk menyesuaikan perilaku kelas turunan.

Berlaku untuk

WaitOne(Int32)

Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs

Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal, menggunakan bilangan bulat bertanda tangan 32-bit untuk menentukan interval waktu dalam milidetik.

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

Parameter

millisecondsTimeout
Int32

Jumlah milidetik untuk menunggu, atau Infinite (-1) untuk menunggu tanpa batas waktu.

Mengembalikan

Boolean

true jika instans saat ini menerima sinyal; jika tidak, false.

Pengecualian

ObjectDisposedException

Instans saat ini telah dibuang.

ArgumentOutOfRangeException

millisecondsTimeout adalah angka negatif selain -1, yang mewakili waktu habis yang tak terbatas.

AbandonedMutexException

Penantian selesai karena utas keluar tanpa melepaskan mutex.

InvalidOperationException

Instans saat ini adalah proksi transparan untuk WaitHandle di domain aplikasi lain.

Contoh

Contoh kode berikut menunjukkan cara menggunakan handel tunggu untuk menjaga agar proses tidak berakhir saat menunggu utas latar belakang selesai dieksekusi.

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

Keterangan

Jika millisecondsTimeout nol, metode tidak memblokir. Ini menguji status handel tunggu dan segera kembali.

Pemanggil metode ini memblokir hingga instans saat ini menerima sinyal atau waktu habis terjadi. Gunakan metode ini untuk memblokir hingga WaitHandle menerima sinyal dari utas lain, seperti dihasilkan ketika operasi asinkron selesai. Untuk informasi selengkapnya, lihat IAsyncResult antarmuka.

Ambil alih metode ini untuk menyesuaikan perilaku kelas turunan.

Memanggil metode ini kelebihan beban sama dengan memanggil WaitOne(Int32, Boolean) kelebihan beban dan menentukan false untuk exitContext.

Berlaku untuk

WaitOne(TimeSpan)

Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs

Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu.

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

Parameter

timeout
TimeSpan

TimeSpan yang mewakili jumlah milidetik untuk menunggu, atau TimeSpan yang mewakili -1 milidetik untuk menunggu tanpa batas waktu.

Mengembalikan

Boolean

true jika instans saat ini menerima sinyal; jika tidak, false.

Pengecualian

ObjectDisposedException

Instans saat ini telah dibuang.

ArgumentOutOfRangeException

timeout adalah angka negatif selain -1 milidetik, yang mewakili waktu habis yang tak terbatas.

-atau-

timeout lebih besar dari Int32.MaxValue.

AbandonedMutexException

Penantian selesai karena utas keluar tanpa melepaskan mutex.

InvalidOperationException

Instans saat ini adalah proksi transparan untuk WaitHandle di domain aplikasi lain.

Keterangan

Jika timeout nol, metode tidak memblokir. Ini menguji status handel tunggu dan segera kembali.

Pemanggil metode ini memblokir hingga instans saat ini menerima sinyal atau waktu habis terjadi. Gunakan metode ini untuk memblokir hingga WaitHandle menerima sinyal dari utas lain, seperti dihasilkan ketika operasi asinkron selesai. Untuk informasi selengkapnya, lihat IAsyncResult antarmuka.

Ambil alih metode ini untuk menyesuaikan perilaku kelas turunan.

Nilai maksimum untuk timeout adalah Int32.MaxValue.

Memanggil metode ini kelebihan beban sama dengan memanggil WaitOne(TimeSpan, Boolean) kelebihan beban dan menentukan false untuk exitContext.

Berlaku untuk

WaitOne(Int32, Boolean)

Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs

Memblokir utas saat ini hingga saat ini WaitHandle menerima sinyal, menggunakan bilangan bulat bertanda tangan 32-bit untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu.

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

Parameter

millisecondsTimeout
Int32

Jumlah milidetik untuk menunggu, atau Infinite (-1) untuk menunggu tanpa batas waktu.

exitContext
Boolean

true untuk keluar dari domain sinkronisasi untuk konteks sebelum menunggu (jika dalam konteks yang disinkronkan), dan memperolehnya kembali setelahnya; jika tidak, false.

Mengembalikan

Boolean

true jika instans saat ini menerima sinyal; jika tidak, false.

Pengecualian

ObjectDisposedException

Instans saat ini telah dibuang.

ArgumentOutOfRangeException

millisecondsTimeout adalah angka negatif selain -1, yang mewakili waktu habis yang tak terbatas.

AbandonedMutexException

Penantian selesai karena utas keluar tanpa melepaskan mutex.

InvalidOperationException

Instans saat ini adalah proksi transparan untuk WaitHandle di domain aplikasi lain.

Contoh

Contoh berikut menunjukkan bagaimana WaitOne(Int32, Boolean) kelebihan beban metode berkinerja ketika dipanggil dalam domain sinkronisasi. Pertama, utas menunggu dengan exitContext diatur ke false dan memblokir hingga batas waktu tunggu berakhir. Utas kedua dijalankan setelah utas pertama berakhir dan menunggu dengan exitContext diatur ke true. Panggilan untuk memberi sinyal handel tunggu untuk utas kedua ini tidak diblokir, dan utas selesai sebelum waktu tunggu habis.

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

Keterangan

Jika millisecondsTimeout nol, metode tidak memblokir. Ini menguji status handel tunggu dan segera kembali.

Jika mutex ditinggalkan, sebuah AbandonedMutexException akan dilemparkan. Mutex yang ditinggalkan sering menunjukkan kesalahan pengkodian yang serius. Dalam kasus mutex di seluruh sistem, mungkin menunjukkan bahwa aplikasi telah dihentikan tiba-tiba (misalnya, dengan menggunakan Windows Task Manager). Pengecualian berisi informasi yang berguna untuk penelusuran kesalahan.

Pemanggil metode ini memblokir hingga instans saat ini menerima sinyal atau waktu habis terjadi. Gunakan metode ini untuk memblokir hingga WaitHandle menerima sinyal dari utas lain, seperti dihasilkan ketika operasi asinkron selesai. Untuk informasi selengkapnya, lihat IAsyncResult antarmuka.

Ambil alih metode ini untuk menyesuaikan perilaku kelas turunan.

Keluar dari konteks

Parameter exitContext tidak berpengaruh kecuali metode ini dipanggil dari dalam konteks terkelola nondefault. Konteks terkelola dapat menjadi nondefault jika utas Anda berada di dalam panggilan ke instans kelas yang berasal dari ContextBoundObject. Bahkan jika saat ini Anda menjalankan metode pada kelas yang tidak berasal dari ContextBoundObject, seperti String, Anda dapat berada dalam konteks nondefault jika ContextBoundObject ada di tumpukan Anda di domain aplikasi saat ini.

Saat kode Anda dijalankan dalam konteks nondefault, menentukan true penyebab exitContext utas keluar dari konteks terkelola nondefault (yaitu, untuk beralih ke konteks default) sebelum menjalankan metode ini. Utas kembali ke konteks nondefault asli setelah panggilan ke metode ini selesai.

Keluar dari konteks dapat berguna ketika kelas yang terikat konteks memiliki SynchronizationAttribute atribut . Dalam hal ini, semua panggilan ke anggota kelas secara otomatis disinkronkan, dan domain sinkronisasi adalah seluruh isi kode untuk kelas. Jika kode dalam tumpukan panggilan anggota memanggil metode ini dan menentukan untuk exitContext, utas true keluar dari domain sinkronisasi, yang memungkinkan utas yang diblokir pada panggilan ke anggota objek mana pun untuk melanjutkan. Ketika metode ini kembali, utas yang melakukan panggilan harus menunggu untuk masuk kembali ke domain sinkronisasi.

Berlaku untuk

WaitOne(TimeSpan, Boolean)

Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs
Sumber:
WaitHandle.cs

Memblokir utas saat ini hingga instans saat ini menerima sinyal, menggunakan TimeSpan untuk menentukan interval waktu dan menentukan apakah akan keluar dari domain sinkronisasi sebelum menunggu.

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

Parameter

timeout
TimeSpan

TimeSpan yang menunjukkan jumlah milidetik untuk menunggu, atau TimeSpan yang mewakili -1 milidetik untuk menunggu tanpa batas waktu.

exitContext
Boolean

true untuk keluar dari domain sinkronisasi untuk konteks sebelum menunggu (jika dalam konteks yang disinkronkan), dan memperolehnya kembali setelahnya; jika tidak, false.

Mengembalikan

Boolean

true jika instans saat ini menerima sinyal; jika tidak, false.

Pengecualian

ObjectDisposedException

Instans saat ini telah dibuang.

ArgumentOutOfRangeException

timeout adalah angka negatif selain -1 milidetik, yang mewakili waktu habis yang tak terbatas.

-atau-

timeout lebih besar dari Int32.MaxValue.

AbandonedMutexException

Penantian selesai karena utas keluar tanpa melepaskan mutex.

InvalidOperationException

Instans saat ini adalah proksi transparan untuk WaitHandle di domain aplikasi lain.

Contoh

Contoh kode berikut menunjukkan cara menggunakan handel tunggu untuk menjaga agar proses tidak berakhir saat menunggu utas latar belakang selesai dieksekusi.

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

Keterangan

Jika timeout nol, metode tidak memblokir. Ini menguji status handel tunggu dan segera kembali.

Jika muteks ditinggalkan, akan AbandonedMutexException dilemparkan. Mutex yang ditinggalkan sering menunjukkan kesalahan pengkodian yang serius. Dalam kasus mutex di seluruh sistem, mungkin menunjukkan bahwa aplikasi telah dihentikan tiba-tiba (misalnya, dengan menggunakan Windows Task Manager). Pengecualian berisi informasi yang berguna untuk penelusuran kesalahan.

Pemanggil metode ini memblokir hingga instans saat ini menerima sinyal atau waktu habis terjadi. Gunakan metode ini untuk memblokir hingga WaitHandle menerima sinyal dari utas lain, seperti dihasilkan ketika operasi asinkron selesai. Untuk informasi selengkapnya, lihat IAsyncResult antarmuka.

Ambil alih metode ini untuk menyesuaikan perilaku kelas turunan.

Nilai maksimum untuk timeout adalah Int32.MaxValue.

Keluar dari konteks

Parameter exitContext tidak berpengaruh kecuali metode ini dipanggil dari dalam konteks terkelola nondefault. Konteks terkelola dapat menjadi nondefault jika utas Anda berada di dalam panggilan ke instans kelas yang berasal dari ContextBoundObject. Bahkan jika saat ini Anda menjalankan metode pada kelas yang tidak berasal dari ContextBoundObject, seperti String, Anda dapat berada dalam konteks nondefault jika ContextBoundObject ada di tumpukan Anda di domain aplikasi saat ini.

Saat kode Anda dijalankan dalam konteks nondefault, menentukan true penyebab exitContext utas keluar dari konteks terkelola nondefault (yaitu, untuk beralih ke konteks default) sebelum menjalankan metode ini. Utas kembali ke konteks nondefault asli setelah panggilan ke metode ini selesai.

Keluar dari konteks dapat berguna ketika kelas yang terikat konteks memiliki SynchronizationAttribute atribut . Dalam hal ini, semua panggilan ke anggota kelas secara otomatis disinkronkan, dan domain sinkronisasi adalah seluruh isi kode untuk kelas . Jika kode dalam tumpukan panggilan anggota memanggil metode ini dan menentukan untuk exitContext, utas true keluar dari domain sinkronisasi, yang memungkinkan utas yang diblokir pada panggilan ke anggota objek mana pun untuk melanjutkan. Ketika metode ini kembali, utas yang melakukan panggilan harus menunggu untuk masuk kembali ke domain sinkronisasi.

Berlaku untuk