WaitHandle.WaitOne 方法

定義

命名空間:: System.Threading

組件:: mscorlib.dll, System.Runtime.dll

組件:: netstandard.dll, System.Runtime.dll

組件:: System.Runtime.dll

組件:: mscorlib.dll

組件:: netstandard.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

阻擋目前執行緒，直到電流 WaitHandle 接收到訊號。

多載

名稱	Description
WaitOne()	阻擋目前執行緒，直到電流 WaitHandle 接收到訊號。
WaitOne(Int32)	在當前執行緒收到訊號前 WaitHandle ，會阻塞該執行緒，並使用 32 位元有號整數來指定以毫秒為單位的時間間隔。
WaitOne(TimeSpan)	阻塞目前執行緒直到目前實例收到訊號，並使用 a TimeSpan 指定時間區間。
WaitOne(Int32, Boolean)	在當前執行緒收到訊號前封鎖該執行緒 WaitHandle ，使用32位元有符號整數指定時間區間，並指定是否在等待前退出同步域。
WaitOne(TimeSpan, Boolean)	阻塞目前執行緒直到目前實例收到訊號，並用 a TimeSpan 指定時間區間，並決定是否在等待前退出同步域。

WaitOne()

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

阻擋目前執行緒，直到電流 WaitHandle 接收到訊號。

public:
 virtual bool WaitOne();

public virtual bool WaitOne();

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

Public Overridable Function WaitOne () As Boolean

傳回

Boolean

true 如果目前的實例收到訊號。如果目前的實例從未被訊號，則 WaitOne() 永遠不會返回。

例外狀況

ObjectDisposedException

目前的實例已經被處理完畢。

AbandonedMutexException

等待結束是因為執行緒退出時未釋放 mutex。

InvalidOperationException

目前的實例是另一個應用域中 a WaitHandle 的透明代理。

範例

以下程式碼範例展示了如何使用等待句柄，防止程序在等待背景執行緒完成執行時終止。

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

備註

AbandonedMutexException 是 .NET Framework 2.0 版本中新增的。在先前版本中，當互斥線被放棄時，該 WaitOne 方法會回傳 true 。遺棄的互斥體通常表示存在嚴重的編碼錯誤。在系統範圍的互斥系統中，可能表示應用程式已被突然終止（例如使用Windows工作管理員）。例外包含對除錯有用的資訊。

呼叫者會無限阻擋，直到當前實例收到訊號。使用此方法阻擋，直到收到 WaitHandle 來自其他執行緒的訊號，例如非同步操作完成時產生的訊號。如需詳細資訊，請參閱 ICollectionViewLiveShaping 介面。

呼叫此方法過載等同於呼叫 WaitOne(Int32, Boolean) 方法過載，並對第一個參數指定 -1 或 Timeout.Infinite ，第二個 false 參數為。

覆寫此方法以自訂衍生類別的行為。

適用於

WaitOne(Int32)

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

在當前執行緒收到訊號前 WaitHandle ，會阻塞該執行緒，並使用 32 位元有號整數來指定以毫秒為單位的時間間隔。

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

參數

millisecondsTimeout: Int32

等待的時間，或無限等待的毫秒數，或 Infinite 是（-1）無限等待的時間。

傳回

Boolean

true如果目前的實例收到訊號;否則，。 false

例外狀況

ObjectDisposedException

目前的實例已經被處理完畢。

ArgumentOutOfRangeException

millisecondsTimeout 是除 -1 以外的負數，而 -1 代表無限次超時。

AbandonedMutexException

等待結束是因為執行緒退出時未釋放 mutex。

InvalidOperationException

目前的實例是另一個應用域中 a WaitHandle 的透明代理。

範例

以下程式碼範例展示了如何使用等待句柄，防止程序在等待背景執行緒完成執行時終止。

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

備註

若 millisecondsTimeout 為零，則該方法不會阻塞。它會測試等候句柄的狀態，並立即傳回。

此方法的呼叫者會阻塞，直到當前實例收到訊號或發生逾時。使用此方法阻擋，直到收到 WaitHandle 來自其他執行緒的訊號，例如非同步操作完成時產生的訊號。如需詳細資訊，請參閱 ICollectionViewLiveShaping 介面。

覆寫此方法以自訂衍生類別的行為。

呼叫此方法的超載，等同於呼叫過 WaitOne(Int32, Boolean) 載並指定 false 為 exitContext。

適用於

WaitOne(TimeSpan)

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

阻塞目前執行緒直到目前實例收到訊號，並使用 a TimeSpan 指定時間區間。

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

參數

timeout: TimeSpan

TimeSpan A 代表等待的毫秒數，或 A TimeSpan 代表無限等待的 -1 毫秒。

傳回

Boolean

true如果目前的實例收到訊號;否則，。 false

例外狀況

ObjectDisposedException

目前的實例已經被處理完畢。

ArgumentOutOfRangeException

timeout 是除 -1 毫秒外的負數，代表無限次逾時。

-或-

timeout 大於 Int32.MaxValue。

AbandonedMutexException

等待結束是因為執行緒退出時未釋放 mutex。

InvalidOperationException

目前的實例是另一個應用域中 a WaitHandle 的透明代理。

備註

若 timeout 為零，則該方法不會阻塞。它會測試等候句柄的狀態，並立即傳回。

覆寫此方法以自訂衍生類別的行為。

最大 timeout 值為 Int32.MaxValue。

呼叫此方法的超載，等同於呼叫過 WaitOne(TimeSpan, Boolean) 載並指定 false 為 exitContext。

適用於

WaitOne(Int32, Boolean)

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

在當前執行緒收到訊號前封鎖該執行緒 WaitHandle ，使用32位元有符號整數指定時間區間，並指定是否在等待前退出同步域。

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

參數

millisecondsTimeout: Int32

等待的時間，或無限等待的毫秒數，或 Infinite 是（-1）無限等待的時間。

exitContext: Boolean

true在等待前退出上下文的同步域（若在同步上下文中），並在等待後重新取得;否則，。 false

傳回

Boolean

true如果目前的實例收到訊號;否則，。 false

例外狀況

ObjectDisposedException

目前的實例已經被處理完畢。

ArgumentOutOfRangeException

millisecondsTimeout 是除 -1 以外的負數，而 -1 代表無限次超時。

AbandonedMutexException

等待結束是因為執行緒退出時未釋放 mutex。

InvalidOperationException

目前的實例是另一個應用域中 a WaitHandle 的透明代理。

範例

以下範例展示了方法過載在同步域內呼叫時的 WaitOne(Int32, Boolean) 行為。首先，執行緒會 exitContext 將設定為並 false 阻塞直到等待逾時結束。第二個執行緒在第一個執行緒終止後執行並等待，並將 exitContext 設為 true。呼叫此第二個執行緒的等待句柄不會被阻塞，且執行緒會在等待逾時前完成。

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

備註

若 millisecondsTimeout 為零，則該方法不會阻塞。它會測試等候句柄的狀態，並立即傳回。

若互斥器被放棄，則拋出 a AbandonedMutexException 。遺棄的互斥體通常表示存在嚴重的編碼錯誤。在系統範圍的互斥系統中，可能表示應用程式已被突然終止（例如使用Windows工作管理員）。例外包含對除錯有用的資訊。

覆寫此方法以自訂衍生類別的行為。

退出語境

除非此方法在非預設的受管理上下文中呼叫，否則該 exitContext 參數不會產生影響。如果你的執行緒位於從衍生 ContextBoundObject的類別實例呼叫中，該受管理上下文可以是非預設的。即使你目前執行的是一個不是源自 ContextBoundObject的類別，例如 String，只要 a ContextBoundObject 在當前應用域的堆疊中，你也可以處於非預設的上下文中。

當你的程式碼在非預設上下文中執行時，指定 true for exitContext 會讓執行緒在執行此方法前退出非預設的管理上下文（也就是轉換到預設上下文）。執行緒在呼叫完成後會回到原始非預設上下文。

當上下文綁定類別擁有屬性 SynchronizationAttribute 時，退出上下文會很有用。在此情況下，對類別成員的所有呼叫都會自動同步處理，而且同步處理網域是類別的整個程式代碼主體。如果成員呼叫堆疊中的程式碼呼叫此方法並指定 true 為 exitContext，該執行緒將退出同步域，允許被阻擋呼叫物件中任一成員的執行緒繼續。當此方法回傳時，呼叫的執行緒必須等待重新進入同步域。

適用於

WaitOne(TimeSpan, Boolean)

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

來源:: WaitHandle.cs

阻塞目前執行緒直到目前實例收到訊號，並用 a TimeSpan 指定時間區間，並決定是否在等待前退出同步域。

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

參數

timeout: TimeSpan

TimeSpan A 代表等待的毫秒數，或 A TimeSpan 代表無限等待的 -1 毫秒。

exitContext: Boolean

true在等待前退出上下文的同步域（若在同步上下文中），並在等待後重新取得;否則，。 false

傳回

Boolean

true如果目前的實例收到訊號;否則，。 false

例外狀況

ObjectDisposedException

目前的實例已經被處理完畢。

ArgumentOutOfRangeException

timeout 是除 -1 毫秒外的負數，代表無限次逾時。

-或-

timeout 大於 Int32.MaxValue。

AbandonedMutexException

等待結束是因為執行緒退出時未釋放 mutex。

InvalidOperationException

目前的實例是另一個應用域中 a WaitHandle 的透明代理。

範例

以下程式碼範例展示了如何使用等待句柄，防止程序在等待背景執行緒完成執行時終止。

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

備註

若 timeout 為零，則該方法不會阻塞。它會測試等候句柄的狀態，並立即傳回。

覆寫此方法以自訂衍生類別的行為。

最大 timeout 值為 Int32.MaxValue。

退出語境

適用於

意見反應

此頁面對您有幫助嗎？