WaitHandle.WaitAll Method (array<WaitHandle[])

Parameters

• waitHandles
  Type: array<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.

Return Value

Type: System.Boolean
true when every element in waitHandles has received a signal; otherwise, the method never returns.

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
      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 &= "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.

      ' 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

      index = WaitHandle.WaitAny(waitHandles)

      ' In an actual application, the result of the first subtask could be 
      ' processed now. 


      ' Wait for ALL subtasks to complete.
      WaitHandle.WaitAll(waitHandles)


      ' 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 Completed(ByVal sender As Object, ByVal e As RunWorkerCompletedEventArgs)

      Dim worker As BackgroundWorker = CType(sender, BackgroundWorker)
      RemoveHandler worker.DoWork, AddressOf DoWork
      RemoveHandler worker.RunWorkerCompleted, AddressOf Completed

      outputBlock.Text &= 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.
'Mouse clicked.
'Task 2 was the first to complete, with a duration of 3.431934 seconds.
'The total duration of all tasks was 11.1537855 seconds.
'
'To repeat the demo, refresh the page.

using System;
using System.Threading;

// The following using statements simplify the supporting code; they are not required 
// for WaitHandle:
using System.Windows.Controls;
using System.Windows.Input;
using System.ComponentModel;

public class Example
{
   private static TextBlock outputBlock;

   public static void Demo(TextBlock outputBlock)
   {
      Example.outputBlock = outputBlock;
      Example.outputBlock.Text = "Click to start the demo.";

      outputBlock.MouseLeftButtonUp += new MouseButtonEventHandler(MouseUpStart);
   }

   private static void MouseUpStart(object sender, MouseEventArgs e)
   {
      // Replace the startup mouse button handler with a handler that 
      // displays a message.
      outputBlock.MouseLeftButtonUp -= new MouseButtonEventHandler(MouseUpStart);
      outputBlock.MouseLeftButtonUp += new MouseButtonEventHandler(MouseUp);

      outputBlock.Text = 
         "Demo is running. The BackgroundWorker waits for the first subtask to complete,\n" +
         "then waits for all subtasks to complete and produces a report.\n" +
         "Click here at any time to show that the user interface is responsive.\n";

      System.ComponentModel.BackgroundWorker worker = new System.ComponentModel.BackgroundWorker();
      worker.DoWork += DoWork;
      worker.RunWorkerCompleted += Completed;
      worker.RunWorkerAsync();
   }

   // The only purpose of this mouse button handler is to show that the user
   // interface is responsive while the background tasks are running.
   //
   private static void MouseUp(object sender, MouseEventArgs e)
   {
      outputBlock.Text += "Mouse clicked.\n";
   }

   private static void DoWork(object sender, DoWorkEventArgs e)
   {
      BackgroundWorker worker = (BackgroundWorker) sender;

      // Divide the "work" into three parts, and queue three tasks to run on
      // threadpool threads. Provide random data for each task.

      Random r = new Random();
      // Keep a list of subtasks and a list of their ManualResetEvent objects.
      System.Collections.Generic.List<Subtask> subtasks = 
                                 new System.Collections.Generic.List<Subtask>();
      System.Collections.Generic.List<WaitHandle> finished = 
                                 new System.Collections.Generic.List<WaitHandle>();

      for(int i = 1; i <= 3; i++)
      {
         Subtask task = new Subtask(i, 3000 + r.Next(4000));
         subtasks.Add(task);
         finished.Add(task.Finished);
         ThreadPool.QueueUserWorkItem(task.DoSubtask);
      }


      // Wait for ANY subtask to complete.

      // Create an array of ManualResetEvent wait handles. Each subtask will
      // signal its ManualResetEvent when it is finished.
      WaitHandle[] waitHandles = finished.ToArray();
      int index = WaitHandle.WaitTimeout;

      index = WaitHandle.WaitAny(waitHandles);

      // In an actual application, the result of the first subtask could be 
      // processed now. 


      // Wait for ALL subtasks to complete.      
      WaitHandle.WaitAll(waitHandles);


      // Generate a report and return it as the result.
      Subtask first = subtasks[index];
      double total = 0.0;

      foreach( Subtask task in subtasks )
      {
         total += task.Result.TotalMilliseconds;
      }

      e.Result = String.Format(
         "Task {0} was the first to complete, with a duration of {1} seconds.\n"
            + "The total duration of all tasks was {2} seconds.\n", 
         first.SubtaskNumber, 
         first.Result.TotalMilliseconds/1000, 
         total/1000);
   }

   private static void Completed(object sender, RunWorkerCompletedEventArgs e)
   {
      BackgroundWorker worker = (BackgroundWorker) sender;
      worker.DoWork -= DoWork;
      worker.RunWorkerCompleted -= Completed;

      outputBlock.Text += 
         String.Format("{0}\nTo repeat the demo, refresh the page.", e.Result);
   }
}

class Subtask
{
   // Signal this ManualResetEvent when the task is finished.
   internal ManualResetEvent Finished = new ManualResetEvent(false);
   internal int SubtaskNumber;
   internal TimeSpan Result;
   private int data;

   internal Subtask(int number, int data)
   {
      SubtaskNumber = number;
      this.data = data;
   }

   internal void DoSubtask(object state)
   {
      DateTime start = DateTime.Now;
      Thread.Sleep(data);
      // Return a TimeSpan that represents the duration of the task.
      Result = DateTime.Now-start;
      Finished.Set();
   }
}

/* 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.
Mouse clicked.
Task 1 was the first to complete, with a duration of 3.3363568 seconds.
The total duration of all tasks was 12.317826 seconds.

To repeat the demo, refresh the page.
 */