.NET并行计算和并发8-QueueUserWorkItem异步

  1     using System;
  2     using System.Threading;
  3 
  4 public static void Main()
  5     {
  6         // Queue the task.
  7         ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc));
  8 
  9         Console.WriteLine("Main thread does some work, then sleeps.");
 10         // If you comment out the Sleep, the main thread exits before
 11         // the thread pool task runs.  The thread pool uses background
 12         // threads, which do not keep the application running.  (This
 13         // is a simple example of a race condition.)
 14         Thread.Sleep(1000);
 15 
 16         Console.WriteLine("Main thread exits.");
 17     }
 18 
 19     // This thread procedure performs the task.
 20     static void ThreadProc(Object stateInfo)
 21     {
 22         // No state object was passed to QueueUserWorkItem, so
 23         // stateInfo is null.
 24         Console.WriteLine("Hello from the thread pool.");
 25     }
 26 

  1 using System;
  2 using System.Threading;
  3 
  4 // TaskInfo holds state information for a task that will be
  5 // executed by a ThreadPool thread.
  6 public class TaskInfo
  7 {
  8     // State information for the task.  These members
  9     // can be implemented as read-only properties, read/write
 10     // properties with validation, and so on, as required.
 11     public string Boilerplate;
 12     public int Value;
 13 
 14     // Public constructor provides an easy way to supply all
 15     // the information needed for the task.
 16     public TaskInfo(string text, int number)
 17     {
 18         Boilerplate = text;
 19         Value = number;
 20     }
 21 }
 22 
 23 public class Example
 24 {
 25     public static void Main()
 26     {
 27         // Create an object containing the information needed
 28         // for the task.
 29         TaskInfo ti = new TaskInfo("This report displays the number {0}.", 42);
 30 
 31         // Queue the task and data.
 32         if (ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc), ti))
 33         {
 34             Console.WriteLine("Main thread does some work, then sleeps.");
 35 
 36             // If you comment out the Sleep, the main thread exits before
 37             // the ThreadPool task has a chance to run.  ThreadPool uses
 38             // background threads, which do not keep the application
 39             // running.  (This is a simple example of a race condition.)
 40             Thread.Sleep(1000);
 41 
 42             Console.WriteLine("Main thread exits.");
 43         }
 44         else
 45         {
 46             Console.WriteLine("Unable to queue ThreadPool request.");
 47         }
 48     }
 49 
 50     // The thread procedure performs the independent task, in this case
 51     // formatting and printing a very simple report.
 52     //
 53     static void ThreadProc(Object stateInfo)
 54     {
 55         TaskInfo ti = (TaskInfo)stateInfo;
 56         Console.WriteLine(ti.Boilerplate, ti.Value);
 57     }
 58 }
 59 

  1 using System;
  2 using System.Threading;
  3 
  4 // TaskInfo contains data that will be passed to the callback
  5 // method.
  6 public class TaskInfo
  7 {
  8     public RegisteredWaitHandle Handle = null;
  9     public string OtherInfo = "default";
 10 }
 11 
 12 public class Example
 13 {
 14     public static void Main(string[] args)
 15     {
 16         // The main thread uses AutoResetEvent to signal the
 17         // registered wait handle, which executes the callback
 18         // method.
 19         AutoResetEvent ev = new AutoResetEvent(false);
 20 
 21         TaskInfo ti = new TaskInfo();
 22         ti.OtherInfo = "First task";
 23         // The TaskInfo for the task includes the registered wait
 24         // handle returned by RegisterWaitForSingleObject.  This
 25         // allows the wait to be terminated when the object has
 26         // been signaled once (see WaitProc).
 27         ti.Handle = ThreadPool.RegisterWaitForSingleObject(
 28             ev,
 29             new WaitOrTimerCallback(WaitProc),
 30             ti,
 31             1000,
 32             false);
 33 
 34         // The main thread waits three seconds, to demonstrate the
 35         // time-outs on the queued thread, and then signals.
 36         Thread.Sleep(3100);
 37         Console.WriteLine("Main thread signals.");
 38         ev.Set();
 39 
 40         // The main thread sleeps, which should give the callback
 41         // method time to execute.  If you comment out this line, the
 42         // program usually ends before the ThreadPool thread can execute.
 43         Thread.Sleep(1000);
 44         // If you start a thread yourself, you can wait for it to end
 45         // by calling Thread.Join.  This option is not available with
 46         // thread pool threads.
 47     }
 48 
 49     // The callback method executes when the registered wait times out,
 50     // or when the WaitHandle (in this case AutoResetEvent) is signaled.
 51     // WaitProc unregisters the WaitHandle the first time the event is
 52     // signaled.
 53     public static void WaitProc(object state, bool timedOut)
 54     {
 55         // The state object must be cast to the correct type, because the
 56         // signature of the WaitOrTimerCallback delegate specifies type
 57         // Object.
 58         TaskInfo ti = (TaskInfo)state;
 59 
 60         string cause = "TIMED OUT";
 61         if (!timedOut)
 62         {
 63             cause = "SIGNALED";
 64             // If the callback method executes because the WaitHandle is
 65             // signaled, stop future execution of the callback method
 66             // by unregistering the WaitHandle.
 67             if (ti.Handle != null)
 68                 ti.Handle.Unregister(null);
 69         }
 70 
 71         Console.WriteLine("WaitProc( {0} ) executes on thread {1}; cause = {2}.",
 72             ti.OtherInfo,
 73             Thread.CurrentThread.GetHashCode().ToString(),
 74             cause
 75         );
 76     }
 77 }
 78