WaitHandle.WaitAll Method (WaitHandle(), TimeSpan)
[ This article is for Windows Phone 8 developers. If you’re developing for Windows 10, see the latest documentation. ]
Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval.
Assembly: mscorlib (in mscorlib.dll)
'Declaration Public Shared Function WaitAll ( _ waitHandles As WaitHandle(), _ timeout As TimeSpan _ ) As Boolean
Parameters
- waitHandles
- Type:
System.Threading.WaitHandle
()
An array that contains the objects for which the current instance will wait. This array cannot contain multiple references to the same object.
- timeout
- Type: System.TimeSpan
A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds, to wait indefinitely.
Return Value
Type: System.Booleantrue when every element in waitHandles has received a signal; otherwise, false.
| Exception | Condition |
|---|---|
| ArgumentNullException | The waitHandles parameter is Nothing. -or- One or more of the objects in the waitHandles array is Nothing. |
| ArgumentException | The waitHandles array contains elements that are duplicates. -or- waitHandles is an array with no elements. |
| NotSupportedException | The number of objects in waitHandles is greater than the system permits. |
| ArgumentOutOfRangeException | timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. -or- timeout is greater than Int32.MaxValue . |
If timeout is zero, the method does not block. It tests the state of the wait handles and returns immediately.
The WaitAll method returns when the wait terminates, either when all the handles are signaled or when a time-out occurs. On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. If the array contains duplicates, the call will fail.
The maximum value for timeout is Int32.MaxValue.
If you call this method from a single-threaded apartment, and waitHandles contains more than one wait handle, the method deadlocks.
Version Notes
Windows Phone
WaitAll is present but not supported in Windows Phone.The following code example shows how to use this overload of the WaitAll method to report progress while waiting for the first of several threads to finish. It also demonstrates the corresponding overload of the WaitAny method.
The example creates a BackgroundWorker that reports progress to the user interface. By using a BackgroundWorker, the example insulates the user interface thread from the effects of the WaitAny and WaitAll methods, and thus allows the user interface to remain responsive.
The BackgroundWorker runs a DoWork method that creates three tasks by using the ThreadPool.QueueUserWorkItem method, and assigns each task a random amount of work. The example defines a Subtask class to hold the data and thread procedure for each task. Each task has a ManualResetEvent, which it signals when its work is complete.
After starting the tasks, the DoWork method uses the WaitAny(WaitHandle(), TimeSpan) method overload to wait for the shortest subtask to finish, with a 250-millisecond time-out to report progress to the user interface. The BackgroundWorker then uses the WaitAll(WaitHandle(), TimeSpan) method overload to wait until the rest of the tasks are complete, once again with a time-out to show progress. The DoWork method then produces a report using the results from all three tasks.
Note: |
|---|
The shortest task is not necessarily the first to complete. The thread pool threads may not all start immediately and may not be treated equally by the scheduler. |
After you start the example, it changes the mouse button event to show user clicks, demonstrating that the user interface remains responsive during the execution of the background tasks.
Note: |
|---|
To run this example, see Building examples that have static TextBlock controls for Windows Phone 8. |
Imports System.Threading ' The following imports simplify the supporting code; they are not required for ' WaitHandle: Imports System.Windows.Controls Imports System.Windows.Input Imports System.ComponentModel Public Class Example Private Shared outputBlock As TextBlock Public Shared Sub Demo(ByVal outputBlock As TextBlock) Example.outputBlock = outputBlock Example.outputBlock.Text = "Click to start the demo." AddHandler outputBlock.MouseLeftButtonUp, AddressOf MouseUpStart End Sub Private Shared Sub MouseUpStart(ByVal sender As Object, ByVal e As MouseEventArgs) ' Replace the startup mouse button handler with a handler that ' displays a message. RemoveHandler outputBlock.MouseLeftButtonUp, AddressOf MouseUpStart AddHandler outputBlock.MouseLeftButtonUp, AddressOf MouseUp outputBlock.Text = _ "Demo is running. The BackgroundWorker waits for the first subtask to complete," & vbLf _ & "then waits for all subtasks to complete and produces a report." & vbLf _ & "Click here at any time to show that the user interface is responsive." & vbLf Dim worker As New System.ComponentModel.BackgroundWorker AddHandler worker.DoWork, AddressOf DoWork worker.WorkerReportsProgress = True AddHandler worker.ProgressChanged, AddressOf Progress AddHandler worker.RunWorkerCompleted, AddressOf Completed worker.RunWorkerAsync() End Sub ' The only purpose of this mouse button handler is to show that the user ' interface is responsive while the background tasks are running. ' Private Shared Sub MouseUp(ByVal sender As Object, ByVal e As MouseEventArgs) outputBlock.Text &= vbLf & "Mouse clicked." & vbLf End Sub Private Shared Sub DoWork(ByVal sender As Object, ByVal e As DoWorkEventArgs) Dim worker As BackgroundWorker = CType(sender, BackgroundWorker) ' Divide the "work" into three parts, and queue three tasks to run on ' threadpool threads. Provide random data for each task. Dim r As New Random() ' Keep a list of subtasks and a list of their ManualResetEvent objects. Dim subtasks As New System.Collections.Generic.List(Of Subtask) Dim finished As New System.Collections.Generic.List(Of WaitHandle) For i As Integer = 1 To 3 Dim task As New Subtask(i, 3000 + r.Next(4000)) subtasks.Add(task) finished.Add(task.Finished) ThreadPool.QueueUserWorkItem(AddressOf task.DoSubtask) Next ' Wait for ANY subtask to complete, and show progress. ' Create an array of ManualResetEvent wait handles. Each subtask will ' signal its ManualResetEvent when it is finished. Dim waitHandles() As WaitHandle = finished.ToArray() Dim index As Integer = WaitHandle.WaitTimeout While index = WaitHandle.WaitTimeout ' Wait for any WaitHandle to be signaled. Use a timeout of 250 milliseconds ' to send progress reports. If a timeout occurs, WaitTimeout is returned; ' if a WaitHandle signals, the array index of the WaitHandle is returned. ' index = WaitHandle.WaitAny(waitHandles, New TimeSpan(0, 0, 0, 0, 250)) worker.ReportProgress(1) End While ' In an actual application, the result of the first subtask could be ' processed now. Instead, signal the user interface that the first ' subtask is done. worker.ReportProgress(2) ' Wait for ALL subtasks to complete, and show progress every 1/4 second if ' the WaitAll times out. While Not WaitHandle.WaitAll(waitHandles, New TimeSpan(0, 0, 0, 0, 250)) ' If the WaitAll timed out, show progress. worker.ReportProgress(3) End While ' Generate a report and return it as the result. Dim first As Subtask = subtasks(index) Dim total As Double = 0.0 For Each task As Subtask In subtasks total += task.Result.TotalMilliseconds Next task e.Result = String.Format( _ "Task {0} was the first to complete, with a duration of {1} seconds." _ & vbLf & "The total duration of all tasks was {2} seconds." & vbLf, _ first.SubtaskNumber, _ first.Result.TotalMilliseconds / 1000, _ total / 1000) End Sub Private Shared Sub Progress(ByVal sender As Object, ByVal e As ProgressChangedEventArgs) If e.ProgressPercentage = 2 Then outputBlock.Text &= vbLf & "First subtask is complete." & vbLf Else outputBlock.Text &= "." End If End Sub Private Shared Sub Completed(ByVal sender As Object, ByVal e As RunWorkerCompletedEventArgs) Dim worker As BackgroundWorker = CType(sender, BackgroundWorker) RemoveHandler worker.DoWork, AddressOf DoWork RemoveHandler worker.ProgressChanged, AddressOf Progress RemoveHandler worker.RunWorkerCompleted, AddressOf Completed outputBlock.Text &= vbLf & e.Result & vbLf & "To repeat the demo, refresh the page." End Sub End Class Class Subtask ' Signal this ManualResetEvent when the task is finished. Friend Finished As New ManualResetEvent(False) Friend SubtaskNumber As Integer Friend Result As TimeSpan Private data As Integer Friend Sub New(ByVal number As Integer, data As Integer) SubtaskNumber = number Me.data = data End Sub Friend Sub DoSubTask(ByVal state As Object) Dim start As DateTime = DateTime.Now Thread.Sleep(data) ' Return a TimeSpan that represents the duration of the task. Result = DateTime.Now - start Finished.Set() End Sub End Class ' This code produces output similar to the following: ' 'Demo is running. The BackgroundWorker waits for the first subtask to complete, 'then waits for all subtasks to complete and produces a report. 'Click here at any time to show that the user interface is responsive. '..... 'Mouse clicked. '........... 'First subtask is complete. '............ 'Task 3 was the first to complete, with a duration of 3.178 seconds. 'The total duration of all tasks was 15.3553943 seconds. ' 'To repeat the demo, refresh the page.
Note: