C# 4 and .NET 4

510 ❘ ChaPTer 20 threAds, tAsks, And synchrOnizAtiOn
t1.Wait();
}
catch (Exception ex)
{
Console.WriteLine("exception: {0}, {1}", ex.GetType().Name,
ex.Message);
if (ex.InnerException != null)
Console.WriteLine("inner exception: {0}, {1}",
ex.InnerException.GetType().Name,
ex.InnerException.Message);
}
Console.WriteLine("status of the task: {0}", t1.Status);
code snippet CancellationSamples/Program.cs
When running the application, you can see that the task starts, runs for a few loops, and gets the
cancellation request. The task is canceled and throws a TaskCanceledException, which is initiated
from the method call ThrowIfCancellationRequested(). With the caller waiting for the task,
you can see that the exception AggregateException is caught and contains the inner exception
TaskCanceledException. This is used for a hierarchy of cancellations, for example, if you run a
Parallel.For within a task that is canceled as well. The final status of the task is Canceled.
in task
in loop
in loop
in loop
in loop
*** task canceled
canceling was requested, canceling from within the task
exception AggregateException, One or more errors occurred.
inner exception TaskCanceledException, A task was canceled.
status of the task: Canceled
Threading issues
Programming with multiple threads is not easy. When starting multiple threads that access the same data,
you can get intermittent problems that are hard to find. This is the same if you use tasks, Parallel LINQ,
or the Parallel class. To avoid getting into trouble, you must pay attention to synchronization issues and
the problems that can happen with multiple threads. We discuss two in particular next: race conditions
and deadlocks.
race Condition
A race condition can occur if two or more threads access the same objects and access to the shared state is
not synchronized.
To demonstrate a race condition, the class StateObject, with an int field and the method ChangeState, is
defined. In the implementation of ChangeState, the state variable is verified to see if it contains 5; if it does,
the value is incremented. Trace.Assert is the next statement, which immediately verifies that state now
contains the value 6.
After incrementing by 1 a variable that contains the value 5, you might expect that the variable now has the
value 6. But this is not necessarily the case. For example, if one thread has just completed the if (state == 5)
statement, it might be preempted and the scheduler run another thread. The second thread now goes into the if
body and, because the state still has the value 5, the state is incremented by 1 to 6. The first thread is now
scheduled again, and in the next statement the state is incremented to 7. This is when the race condition
occurs and the assert message is shown.
www.it-ebooks.info