WaitHandle.WaitOne Metod

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

public:
 virtual bool WaitOne();

public virtual bool WaitOne();

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

Public Overridable Function WaitOne () As Boolean

Returer

true om den aktuella instansen tar emot en signal. Om den aktuella instansen aldrig signaleras WaitOne() returneras aldrig.

Undantag

Exempel

I följande kodexempel visas hur du använder ett väntehandtag för att förhindra att en process avslutas medan den väntar på att en bakgrundstråd ska slutföra körningen.

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

Kommentarer

AbandonedMutexException är nytt i .NET Framework version 2.0. I tidigare versioner WaitOne returnerar true metoden när en mutex avbryts. Ett övergivet mutex indikerar ofta ett allvarligt kodfel. När det gäller en systemomfattande mutex kan det tyda på att ett program har avslutats plötsligt (till exempel med hjälp av Windows Aktivitetshanteraren). Undantaget innehåller information som är användbar för felsökning.

Anroparen för den här metoden blockerar på obestämd tid tills den aktuella instansen tar emot en signal. Använd den här metoden för att blockera tills en WaitHandle tar emot en signal från en annan tråd, till exempel genereras när en asynkron åtgärd slutförs. Mer information finns i IAsyncResult-gränssnittet.

Att anropa den här metodens överlagring motsvarar att anropa WaitOne(Int32, Boolean) metodens överlagring och ange -1 eller Timeout.Infinite för den första parametern och false för den andra parametern.

Åsidosätt den här metoden för att anpassa beteendet för härledda klasser.

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

public:
 virtual bool WaitOne(int millisecondsTimeout);

public virtual bool WaitOne(int millisecondsTimeout);

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

Public Overridable Function WaitOne (millisecondsTimeout As Integer) As Boolean

Parametrar

Returer

trueom den aktuella instansen tar emot en signal; annars . false

Undantag

Exempel

I följande kodexempel visas hur du använder ett väntehandtag för att förhindra att en process avslutas medan den väntar på att en bakgrundstråd ska slutföra körningen.

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

Kommentarer

Om millisecondsTimeout är noll blockeras inte metoden. Den testar tillståndet för väntehandtaget och returnerar omedelbart.

Anroparen för den här metoden blockerar tills den aktuella instansen tar emot en signal eller en timeout inträffar. Använd den här metoden för att blockera tills en WaitHandle tar emot en signal från en annan tråd, till exempel genereras när en asynkron åtgärd slutförs. Mer information finns i IAsyncResult-gränssnittet.

Åsidosätt den här metoden för att anpassa beteendet för härledda klasser.

Att anropa den här metodens överlagring är detsamma som att anropa överlagringen WaitOne(Int32, Boolean) och ange false för exitContext.

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

public:
 virtual bool WaitOne(TimeSpan timeout);

public virtual bool WaitOne(TimeSpan timeout);

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

Public Overridable Function WaitOne (timeout As TimeSpan) As Boolean

Parametrar

Returer

trueom den aktuella instansen tar emot en signal; annars . false

Undantag

Kommentarer

Om timeout är noll blockeras inte metoden. Den testar tillståndet för väntehandtaget och returnerar omedelbart.

Anroparen för den här metoden blockerar tills den aktuella instansen tar emot en signal eller en timeout inträffar. Använd den här metoden för att blockera tills en WaitHandle tar emot en signal från en annan tråd, till exempel genereras när en asynkron åtgärd slutförs. Mer information finns i IAsyncResult-gränssnittet.

Åsidosätt den här metoden för att anpassa beteendet för härledda klasser.

Det maximala värdet för timeout är Int32.MaxValue.

Att anropa den här metodens överlagring är detsamma som att anropa överlagringen WaitOne(TimeSpan, Boolean) och ange false för exitContext.

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

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

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

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

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

Parametrar

Returer

trueom den aktuella instansen tar emot en signal; annars . false

Undantag

Exempel

I följande exempel visas hur WaitOne(Int32, Boolean) metodens överlagring fungerar när den anropas inom en synkroniseringsdomän. Först väntar en tråd med exitContext inställt på false och blockerar tills tidsgränsen för väntetiden upphör att gälla. En andra tråd körs när den första tråden avslutas och väntar med exitContext inställt på true. Anropet för att signalera väntehandtaget för den andra tråden blockeras inte, och tråden slutförs före tidsgränsen för väntetiden.

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

Kommentarer

Om millisecondsTimeout är noll blockeras inte metoden. Den testar tillståndet för väntehandtaget och returnerar omedelbart.

Om en mutex överges utlöses en AbandonedMutexException . Ett övergivet mutex indikerar ofta ett allvarligt kodfel. När det gäller en systemomfattande mutex kan det tyda på att ett program har avslutats plötsligt (till exempel med hjälp av Windows Aktivitetshanteraren). Undantaget innehåller information som är användbar för felsökning.

Anroparen för den här metoden blockerar tills den aktuella instansen tar emot en signal eller en timeout inträffar. Använd den här metoden för att blockera tills en WaitHandle tar emot en signal från en annan tråd, till exempel genereras när en asynkron åtgärd slutförs. Mer information finns i IAsyncResult-gränssnittet.

Åsidosätt den här metoden för att anpassa beteendet för härledda klasser.

Avsluta kontexten

Parametern exitContext har ingen effekt om inte den här metoden anropas inifrån en nondefault-hanterad kontext. Den hanterade kontexten kan vara nondefault om tråden finns i ett anrop till en instans av en klass som härletts från ContextBoundObject. Även om du för närvarande kör en metod på en klass som inte härleds från ContextBoundObject, till exempel String, kan du vara i en nondefault-kontext om en ContextBoundObject finns på stacken i den aktuella programdomänen.

När koden körs i en nondefault-kontext anger du true för exitContext att tråden ska avsluta den nondefault-hanterade kontexten (dvs. att övergå till standardkontexten) innan den här metoden körs. Tråden återgår till den ursprungliga nondefault-kontexten när anropet till den här metoden har slutförts.

Det kan vara användbart att avsluta kontexten när den kontextbundna klassen har attributet SynchronizationAttribute . I så fall synkroniseras alla anrop till medlemmar i klassen automatiskt och synkroniseringsdomänen är hela kodtexten för klassen. Om kod i anropsstacken för en medlem anropar true den här metoden och anger för exitContextavslutar tråden synkroniseringsdomänen, vilket gör att en tråd som blockeras vid ett anrop till alla medlemmar i objektet kan fortsätta. När den här metoden returneras måste tråden som gjorde anropet vänta tills synkroniseringsdomänen har återaktiviserats.

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

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

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

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

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

Parametrar

Returer

trueom den aktuella instansen tar emot en signal; annars . false

Undantag

Exempel

I följande kodexempel visas hur du använder ett väntehandtag för att förhindra att en process avslutas medan den väntar på att en bakgrundstråd ska slutföra körningen.

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

Kommentarer

Om timeout är noll blockeras inte metoden. Den testar tillståndet för väntehandtaget och returnerar omedelbart.

Om en mutex överges utlöses en AbandonedMutexException . Ett övergivet mutex indikerar ofta ett allvarligt kodfel. När det gäller en systemomfattande mutex kan det tyda på att ett program har avslutats plötsligt (till exempel med hjälp av Windows Aktivitetshanteraren). Undantaget innehåller information som är användbar för felsökning.

Anroparen för den här metoden blockerar tills den aktuella instansen tar emot en signal eller en timeout inträffar. Använd den här metoden för att blockera tills en WaitHandle tar emot en signal från en annan tråd, till exempel genereras när en asynkron åtgärd slutförs. Mer information finns i IAsyncResult-gränssnittet.

Åsidosätt den här metoden för att anpassa beteendet för härledda klasser.

Det maximala värdet för timeout är Int32.MaxValue.

Avsluta kontexten

Parametern exitContext har ingen effekt om inte den här metoden anropas inifrån en nondefault-hanterad kontext. Den hanterade kontexten kan vara nondefault om tråden finns i ett anrop till en instans av en klass som härletts från ContextBoundObject. Även om du för närvarande kör en metod på en klass som inte härleds från ContextBoundObject, till exempel String, kan du vara i en nondefault-kontext om en ContextBoundObject finns på stacken i den aktuella programdomänen.

När koden körs i en nondefault-kontext anger du true för exitContext att tråden ska avsluta den nondefault-hanterade kontexten (dvs. att övergå till standardkontexten) innan den här metoden körs. Tråden återgår till den ursprungliga nondefault-kontexten när anropet till den här metoden har slutförts.

Det kan vara användbart att avsluta kontexten när den kontextbundna klassen har attributet SynchronizationAttribute . I så fall synkroniseras alla anrop till medlemmar i klassen automatiskt och synkroniseringsdomänen är hela kodtexten för klassen. Om kod i anropsstacken för en medlem anropar true den här metoden och anger för exitContextavslutar tråden synkroniseringsdomänen, vilket gör att en tråd som blockeras vid ett anrop till alla medlemmar i objektet kan fortsätta. När den här metoden returneras måste tråden som gjorde anropet vänta tills synkroniseringsdomänen har återaktiviserats.