Free-ebooks-library - Bahar Ali Khan

There are, however, some cases where you don’t need to handle exceptions on a
worker thread, because the .NET Framework does it for you. These are covered in
upcoming sections, and are:
• Asynchronous delegates
• BackgroundWorker
• The Task Parallel Library (conditions apply)
Thread Pooling
Whenever you start a thread, a few hundred microseconds are spent organizing such
things as a fresh private local variable stack. Each thread also consumes (by default)
around 1 MB of memory. The thread pool cuts these overheads by sharing and recycling
threads, allowing multithreading to be applied at a very granular level without
a performance penalty. This is useful when leveraging multicore processors to
execute computationally intensive code in parallel in “divide-and-conquer” style.
The thread pool also keeps a lid on the total number of worker threads it will run
simultaneously. Too many active threads throttle the operating system with administrative
burden and render CPU caches ineffective. Once a limit is reached, jobs
queue up and start only when another finishes. This makes arbitrarily concurrent
applications possible, such as a web server. (The asynchronous method pattern takes
this further by making highly efficient use of the pooled threads; see Chapter 23.)
There are a number of ways to enter the thread pool:
• Via the Task Parallel Library or PLINQ (from Framework 4.0)
• By calling ThreadPool.QueueUserWorkItem
• Via asynchronous delegates
• Via BackgroundWorker
The following constructs use the thread pool indirectly:
• WCF, Remoting, ASP.NET, and ASMX Web Services application
servers
• System.Timers.Timer and System.Threading.Timer
• Framework methods that end in Async, such as those on
WebClient (the event-based asynchronous pattern), and
most BeginXXX methods (the asynchronous programming
model pattern)
The Task Parallel Library (TPL) and PLINQ are sufficiently powerful and high-level
that you’ll want to use them to assist in multithreading even when thread pooling
is unimportant. We discuss this fully in the following chapter. Right now, we’ll look
briefly at how you can use the Task class as a simple means of running a delegate on
a pooled thread.
800 | Chapter 21: Threading