C# 4 and .NET 4

Thread Pools ❘ 499
The time quantum and round - robin principles are used only if multiple threads are running at the same
priority. The priority is dynamic. If a thread is CPU - intensive (requires the CPU continuously without
waiting for resources), the priority is lowered to the level of the base priority that is defi ned with the thread.
If a thread is waiting for a resource, the thread gets a priority boost and the priority is increased. Because of
the boost, there is a good chance that the thread gets the CPU the next time that the wait ends.
With the Thread class, you can infl uence the base priority of the thread by setting the Priority property.
The Priority property requires a value that is defi ned by the ThreadPriority enumeration. The levels
defi ned are Highest , AboveNormal , Normal , BelowNormal , and Lowest .
Be careful when giving a thread a higher priority, because this may decrease the chance
for other threads to run. You can change the priority for a short time if necessary.
Controlling Threads
The thread is created by invoking the Start() method of a Thread object. However, after invoking the
Start() method, the new thread is still not in the Running state, but in the Unstarted state. The thread
changes to the Running state as soon as the operating system thread scheduler selects the thread to run. You
can read the current state of a thread by reading the property Thread.ThreadState .
With the Thread.Sleep() method, a thread goes into the WaitSleepJoin state and waits until it is woken
up again after the time span defi ned with the Sleep() method has elapsed.
To stop another thread, you can invoke the method Thread.Abort() . When this method is called, an
exception of type ThreadAbortException is thrown in the thread that receives the abort. With a
handler to catch this exception, the thread can do some cleanup before it ends. The thread also has
a chance to continue running after receiving the ThreadAbortException as a result of invoking Thread.
ResetAbort() . The state of the thread receiving the abort request changes from AbortRequested to the
Aborted state if the thread does not reset the abort.
If you need to wait for a thread to end, you can invoke the Thread.Join() method. Thread.Join() blocks
the current thread and sets it to the WaitSleepJoin state until the thread that is joined is completed.
Thread Pools
Creating threads takes time. When you have different short tasks to do, you can create a number of threads
in advance and send requests as they should be done. It would be nice if this number increased as more
threads were needed and decreased as needed to release resources.
There is no need to create such a list on your own. The list is managed by the ThreadPool class. This class
increases and decreases the number of threads in the pool as they are needed, up to the maximum number
of threads. The maximum number of threads in a pool is confi gurable. With a dual - core CPU, the default
number is set to 1,023 worker threads and 1,000 I/O threads. You can specify the minimum number of
threads that should be started immediately when the pool is created and the maximum number of threads
that are available in the pool. If there are more jobs to process, and the maximum number of threads in the
pool has already been reached, the newest jobs are queued and must wait for a thread to complete its work.
The following sample application fi rst reads the maximum number of worker and I/O threads and writes
this information to the console. Then, in a for loop, the method JobForAThread() is assigned to a thread
from the thread pool by invoking the method ThreadPool.QueueUserWorkItem() and passing a delegate
of type WaitCallback . The thread pool receives this request and selects one of the threads from the pool to
invoke the method. If the pool is not already running, the pool is created and the fi rst thread is started. If
the pool is already running and one thread is free to do the task, the job is forwarded to that thread.
www.it-ebooks.info