© 2006-2010 Joseph Albahari, O’Reilly Media, Inc. All rights reserved. www.albahari.com/threading/
16
Entering the Thread Pool Without TPL
You can't use the Task Parallel Library if you're targeting an earlier version of the .NET Framework (prior to 4.0).
Instead, you must use one of the older constructs for entering the thread pool:
ThreadPool.QueueUserWorkItem
and
asynchronous delegates. The difference between the two is that asynchronous delegates let you return data from the
thread. Asynchronous delegates also marshal any exception back to the caller.
QueueUserWorkItem
To use
QueueUserWorkItem
, simply call this method with a delegate that you want to run on a pooled thread:
static void Main()
{
ThreadPool.QueueUserWorkItem (Go);
ThreadPool.QueueUserWorkItem (Go, 123);
Console.ReadLine();
}
static void Go (object data) //
data
will be null with the first call.
{
Console.WriteLine ("Hello from the thread pool! " + data);
}
// Output:
Hello from the thread pool!
Hello from the thread pool! 123
Our target method,
Go
, must accept a single
object
argument (to satisfy the
WaitCallback
delegate). This provides a
convenient way of passing data to the method, just like with
ParameterizedThreadStart
. Unlike with
Task
,
QueueUserWorkItem
doesn't return an object to help you subsequently manage execution. Also, you must explicitly
deal with exceptions in the target code—unhandled exceptions will take down the program.
Asynchronous delegates
ThreadPool.QueueUserWorkItem
doesn’t provide an easy mechanism for getting return values back from a thread
after it has finished executing. Asynchronous delegate invocations (asynchronous delegates for short) solve this,
allowing any number of typed arguments to be passed in both directions. Furthermore, unhandled exceptions on
asynchronous delegates are conveniently rethrown on the original thread (or more accurately, the thread that calls
EndInvoke
), and so they don’t need explicit handling.
Don’t confuse asynchronous delegates with asynchronous methods (methods starting with Begin or End, such
as
File.BeginRead
/
File.EndRead
). Asynchronous methods follow a similar protocol outwardly, but they
exist to solve a much harder problem, which we describe in Chapter 23 of C# 4.0 in a Nutshell.
Here’s how you start a worker task via an asynchronous delegate:
1. Instantiate a delegate targeting the method you want to run in parallel (typically one of the predefined
Func
delegates).
2. Call
BeginInvoke
on the delegate, saving its
IAsyncResult
return value.
BeginInvoke
returns immediately to the caller. You can then perform other activities while the pooled
thread is working.
3. When you need the results, call
EndInvoke
on the delegate, passing in the saved
IAsyncResult
object.
In the following example, we use an asynchronous delegate invocation to execute concurrently with the main thread, a
simple method that returns a string’s length:
剩余124页未读，继续阅读
