Free-ebooks-library - Bahar Ali Khan

we’re using it to pass the method delegate to the completion callback, so we can call
EndInvoke on it.
Optimizing the Thread Pool
The thread pool starts out with one thread in its pool. As tasks are assigned, the pool
manager “injects” new threads to cope with the extra concurrent workload, up to a
maximum limit. After a sufficient period of inactivity, the pool manager may “retire”
threads if it suspects that doing so will lead to better throughput.
You can set the upper limit of threads that the pool will create by calling Thread
Pool.SetMaxThreads; the defaults are:
• 1023 in Framework 4.0 in a 32-bit environment
• 32768 in Framework 4.0 in a 64-bit environment
• 250 per core in Framework 3.5
• 25 per core in Framework 2.0
(These figures may vary according to the hardware and operating system.) The reason
for there being that many is to ensure progress should some threads be blocked
(idling while awaiting some condition, such as a response from a remote computer).
You can also set a lower limit by calling ThreadPool.SetMinThreads. The role of the
lower limit is subtler: it’s an advanced optimization technique that instructs the pool
manager not to delay in the allocation of threads until reaching the lower limit.
Raising the minimum thread count improves concurrency when there are blocked
threads (see sidebar).
Synchronization
The default lower limit is one thread per processor core—the
minimum that allows full CPU utilization. On server environments,
though (such ASP.NET under IIS), the lower limit is
typically much higher—as much as 50 or more.
So far, we’ve described how to start a task on a thread, configure a thread, and pass
data in both directions. We’ve also described how local variables are private to a
thread and how references can be shared among threads, allowing them to communicate
via common fields.
The next step is synchronization: coordinating the actions of threads for a predictable
outcome. Synchronization is particularly important when threads access the same
data; it’s surprisingly easy to run aground in this area.
Synchronization constructs can be divided into four categories:
Simple blocking methods
These wait for another thread to finish or for a period of time to elapse. Sleep,
Join, and Task.Wait are simple blocking methods.
Synchronization | 805
Threading