C# 4 and .NET 4

Threading issues ❘ 513
}
}
}
state++;
Trace.Assert(state == 6, "Race condition occurred after " +
loop + " loops");
}
state = 5;
code snippet ThreadingIssues/SampleTask.cs
deadlock
Too much locking can get you in trouble as well. In a deadlock, at least two threads halt and wait for
each other to release a lock. As both threads wait for each other, a deadlock occurs and the threads
wait endlessly.
To demonstrate deadlocks, two objects of type StateObject are instantiated and passed with the
constructor of the SampleTask class. Two tasks are created: one task running the method Deadlock1() and
the other task running the method Deadlock2():
var state1 = new StateObject();
var state2 = new StateObject();
new Task(new SampleTask(state1, state2).Deadlock1).Start();
new Task(new SampleTask(state1, state2).Deadlock2).Start();
code snippet ThreadingIssues/Program.cs
The methods Deadlock1() and Deadlock2() now change the state of two objects: s1 and s2. That’s why
two locks are generated. The method Deadlock1() first does a lock for s1 and next for s2. The method
Deadlock2() first does a lock for s2 and then for s1. Now, it may happen from time to time that the lock
for s1 in Deadlock1() is resolved. Next, a thread switch occurs, and Deadlock2() starts to run and
gets the lock for s2. The second thread now waits for the lock of s1. Because it needs to wait, the thread
scheduler schedules the first thread again, which now waits for s2. Both threads now wait and don’t release
the lock as long as the lock block is not ended. This is a typical deadlock.
public class SampleThread
{
public SampleThread(StateObject s1, StateObject s2)
{
this.s1 = s1;
this.s2 = s2;
}
private StateObject s1;
private StateObject s2;
public void Deadlock1()
{
int i = 0;
while (true)
{
lock (s1)
{
lock (s2)
{
s1.ChangeState(i);
s2.ChangeState(i++);
Console.WriteLine("still running, {0}", i);
}
}
}
www.it-ebooks.info