次の方法で共有


WaitHandle.WaitOne メソッド

定義

現在の WaitHandle がシグナルを受け取るまで、現在のスレッドをブロックします。

オーバーロード

WaitOne()

現在の WaitHandle がシグナルを受け取るまで、現在のスレッドをブロックします。

WaitOne(Int32)

32 ビット符号付き整数を使用して時間間隔をミリ秒単位で指定し、現在の WaitHandle がシグナルを受信するまで、現在のスレッドをブロックします。

WaitOne(TimeSpan)

TimeSpan を使用して時間間隔を指定し、現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。

WaitOne(Int32, Boolean)

現在の WaitHandle がシグナルを受信するまで現在のスレッドをブロックします。時間間隔を指定するために 32 ビット符号付き整数を使用し、待機の前でも同期ドメインを終了するかどうかを指定します。

WaitOne(TimeSpan, Boolean)

現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。TimeSpan を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。

WaitOne()

ソース:
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

戻り値

現在のインスタンスがシグナルを受け取った場合は true。 現在のインスタンスがシグナルを受け取らない場合は、WaitOne() はシグナルを受け取るまで待機を続けます。

例外

現在のインスタンスは既に破棄されています。

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

次のコード例は、待機ハンドルを使用して、バックグラウンド スレッドの実行が完了するまでプロセスが終了しないようにする方法を示しています。

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

注釈

AbandonedMutexExceptionは、.NET Framework バージョン 2.0 の新機能です。 以前のバージョンでは、 WaitOne ミューテックスが破棄されると、 メソッドは を返 true します。 破棄されたミューテックスは、多くの場合、深刻なコーディング エラーを示します。 システム全体のミューテックスの場合、アプリケーションが突然終了したことを示している可能性があります (たとえば、Windows タスク マネージャーを使用)。 例外には、デバッグに役立つ情報が含まれています。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するまで無期限にブロックします。 非同期操作が完了したときにが生成されるなど、別のスレッドからシグナルを受信するまで WaitHandle をブロックするには、このメソッドを使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

このメソッド オーバーロードの呼び出しは、メソッド オーバーロードを WaitOne(Int32, Boolean) 呼び出し、-1 または Timeout.Infinite 最初のパラメーターと false 2 番目のパラメーターを指定することと同じです。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

適用対象

WaitOne(Int32)

ソース:
WaitHandle.cs
ソース:
WaitHandle.cs
ソース:
WaitHandle.cs

32 ビット符号付き整数を使用して時間間隔をミリ秒単位で指定し、現在の WaitHandle がシグナルを受信するまで、現在のスレッドをブロックします。

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)。

戻り値

現在のインスタンスがシグナルを受け取る場合は true。それ以外の場合は false

例外

現在のインスタンスは既に破棄されています。

millisecondsTimeout は無限のタイムアウトを表す -1 以外の負の数です。

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

次のコード例は、待機ハンドルを使用して、バックグラウンド スレッドの実行が完了するまでプロセスが終了しないようにする方法を示しています。

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

注釈

が 0 の場合 millisecondsTimeout 、メソッドはブロックしません。 待機ハンドルの状態をテストし、すぐにを返します。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するか、タイムアウトが発生するまでブロックします。 非同期操作が完了したときにが生成されるなど、別のスレッドからシグナルを受信するまで WaitHandle をブロックするには、このメソッドを使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

このメソッド オーバーロードの呼び出しは、 オーバーロードを呼び出し、 に WaitOne(Int32, Boolean)exitContext指定するのfalseと同じです。

適用対象

WaitOne(TimeSpan)

ソース:
WaitHandle.cs
ソース:
WaitHandle.cs
ソース:
WaitHandle.cs

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。無制限に待機する場合は、-1 ミリ秒を表す TimeSpan

戻り値

現在のインスタンスがシグナルを受け取る場合は true。それ以外の場合は false

例外

現在のインスタンスは既に破棄されています。

timeout は無限のタイムアウトを表す -1 ミリ秒以外の負の数です。

または

timeoutInt32.MaxValue より大きい。

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

注釈

が 0 の場合 timeout 、メソッドはブロックしません。 待機ハンドルの状態をテストし、すぐにを返します。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するか、タイムアウトが発生するまでブロックします。 非同期操作が完了したときにが生成されるなど、別のスレッドからシグナルを受信するまで WaitHandle をブロックするには、このメソッドを使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

timeout 最大値は です Int32.MaxValue

このメソッド オーバーロードの呼び出しは、 オーバーロードを呼び出し、 に WaitOne(TimeSpan, Boolean)exitContext指定するのfalseと同じです。

適用対象

WaitOne(Int32, Boolean)

ソース:
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

戻り値

現在のインスタンスがシグナルを受け取る場合は true。それ以外の場合は false

例外

現在のインスタンスは既に破棄されています。

millisecondsTimeout は無限のタイムアウトを表す -1 以外の負の数です。

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

次の例は、同期ドメイン内で WaitOne(Int32, Boolean) 呼び出されたときにメソッド オーバーロードがどのように動作するかを示しています。 最初に、スレッドは を に設定してexitContextfalse待機し、待機タイムアウトが切れるまでブロックします。 2 番目のスレッドは、最初のスレッドが終了して を に設定して exitContext 待機した後に true実行されます。 この 2 番目のスレッドの待機ハンドルを通知する呼び出しはブロックされず、待機タイムアウトの前にスレッドが完了します。

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

注釈

が 0 の場合 millisecondsTimeout 、メソッドはブロックしません。 待機ハンドルの状態をテストし、すぐにを返します。

ミューテックスが破棄されると、 AbandonedMutexException がスローされます。 破棄されたミューテックスは、多くの場合、深刻なコーディング エラーを示します。 システム全体のミューテックスの場合、アプリケーションが突然終了したことを示している可能性があります (たとえば、Windows タスク マネージャーを使用)。 例外には、デバッグに役立つ情報が含まれています。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するか、タイムアウトが発生するまでブロックします。 非同期操作が完了したときにが生成されるなど、別のスレッドからシグナルを受信するまで WaitHandle をブロックするには、このメソッドを使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

コンテキストの終了

パラメーターは、既定以外の exitContext マネージド コンテキスト内からこのメソッドが呼び出されない限り、効果はありません。 スレッドが から ContextBoundObject派生したクラスのインスタンスの呼び出し内にある場合、マネージド コンテキストは既定以外の状態にすることができます。 などString、 からContextBoundObject派生していないクラスでメソッドを現在実行している場合でも、 が現在のアプリケーション ドメインのスタック上にある場合ContextBoundObjectは、既定以外のコンテキストに置くことができます。

コードが既定以外のコンテキストで実行されている場合、 を指定trueexitContextすると、このメソッドを実行する前に、既定以外のマネージド コンテキスト (つまり、既定のコンテキストに遷移する) がスレッドによって終了します。 このメソッドの呼び出しが完了すると、スレッドは既定以外の元のコンテキストに戻ります。

コンテキストバインド クラス SynchronizationAttribute に 属性がある場合は、コンテキストを終了すると便利です。 その場合、クラスのメンバーに対するすべての呼び出しが自動的に同期され、同期ドメインはクラスのコード全体です。 メンバーの呼び出し履歴内のコードがこのメソッドを呼び出し、 に をexitContext指定trueすると、スレッドは同期ドメインを終了します。これにより、オブジェクトの任意のメンバーへの呼び出しでブロックされたスレッドが続行できるようになります。 このメソッドが返された場合、呼び出しを行ったスレッドは、同期ドメインの再入力を待機する必要があります。

適用対象

WaitOne(TimeSpan, Boolean)

ソース:
WaitHandle.cs
ソース:
WaitHandle.cs
ソース:
WaitHandle.cs

現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。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。無制限に待機する場合は、-1 ミリ秒を表す TimeSpan

exitContext
Boolean

待機する前にコンテキストの同期ドメインを終了し (同期されたコンテキスト内にいる場合)、後で再取得する場合は、true。それ以外の場合は false

戻り値

現在のインスタンスがシグナルを受け取る場合は true。それ以外の場合は false

例外

現在のインスタンスは既に破棄されています。

timeout は無限のタイムアウトを表す -1 ミリ秒以外の負の数です。

または

timeoutInt32.MaxValue より大きい。

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

次のコード例は、待機ハンドルを使用して、バックグラウンド スレッドの実行が完了するまでプロセスが終了しないようにする方法を示しています。

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

注釈

が 0 の場合 timeout 、メソッドはブロックしません。 待機ハンドルの状態をテストし、すぐにを返します。

ミューテックスが破棄されると、 AbandonedMutexException がスローされます。 破棄されたミューテックスは、多くの場合、深刻なコーディング エラーを示します。 システム全体のミューテックスの場合、アプリケーションが突然終了したことを示している可能性があります (たとえば、Windows タスク マネージャーを使用)。 例外には、デバッグに役立つ情報が含まれています。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するか、タイムアウトが発生するまでブロックします。 非同期操作が完了したときにが生成されるなど、別のスレッドからシグナルを受信するまで WaitHandle をブロックするには、このメソッドを使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

timeout 最大値は です Int32.MaxValue

コンテキストの終了

パラメーターは、既定以外の exitContext マネージド コンテキスト内からこのメソッドが呼び出されない限り、効果はありません。 スレッドが から ContextBoundObject派生したクラスのインスタンスの呼び出し内にある場合、マネージド コンテキストは既定以外の状態にすることができます。 などString、 からContextBoundObject派生していないクラスでメソッドを現在実行している場合でも、 が現在のアプリケーション ドメインのスタック上にある場合ContextBoundObjectは、既定以外のコンテキストに置くことができます。

コードが既定以外のコンテキストで実行されている場合、 を指定trueexitContextすると、このメソッドを実行する前に、既定以外のマネージド コンテキスト (つまり、既定のコンテキストに遷移する) がスレッドによって終了します。 このメソッドの呼び出しが完了すると、スレッドは既定以外の元のコンテキストに戻ります。

コンテキストバインド クラス SynchronizationAttribute に 属性がある場合は、コンテキストを終了すると便利です。 その場合、クラスのメンバーに対するすべての呼び出しが自動的に同期され、同期ドメインはクラスのコード全体です。 メンバーの呼び出し履歴内のコードがこのメソッドを呼び出し、 に をexitContext指定trueすると、スレッドは同期ドメインを終了します。これにより、オブジェクトの任意のメンバーへの呼び出しでブロックされたスレッドが続行できるようになります。 このメソッドが返された場合、呼び出しを行ったスレッドは、同期ドメインの再入力を待機する必要があります。

適用対象