C# 4 and .NET 4

522 ❘ ChaPTer 20 threAds, tAsks, And synchrOnizAtiOn
s p in lock
The SpinLock struct is new with .NET 4. If the overhead on object - based lock objects ( Monitor ) would
be too high because of garbage collection, SpinLock can be used. SpinLock is useful if you have a high
number of locks (for example, for every node in a list) and hold times are always extremely short. You
should avoid holding more than one SpinLock and don ’ t call anything that might block.
Other than the architectural differences, SpinLock is very similar in usage to the Monitor class. Acquiring
the lock is done with Enter() or TryEnter() and releasing the lock with Exit() . SpinLock also offers
properties to provide information if it is currently locked: IsHeld and IsHeldByCurrentThread .
Be careful when passing SpinLock instances around. Because SpinLock is defi ned
as a struct , assigning one variable to another creates a copy. Always pass SpinLock
instances by reference.
Wait h andle
WaitHandle is an abstract base class that you can use to wait for a signal to be set. There are different
things you can wait for, because WaitHandle is a base class and some classes are derived from it.
When describing asynchronous delegates earlier in this chapter, the WaitHandle was already in use. The
method BeginInvoke() of the asynchronous delegate returns an object that implements the interface
IAsyncResult . Using IAsyncResult , you can access a WaitHandle with the property AsyncWaitHandle .
When you invoke the method WaitOne() , the thread waits until a signal is received that is associated with
the wait handle.
static void Main()
{
TakesAWhileDelegate d1 = TakesAWhile;
}
IAsyncResult ar = d1.BeginInvoke(1, 3000, null, null);
while (true)
{
Console.Write(".");
if (ar.AsyncWaitHandle.WaitOne(50, false))
{
Console.WriteLine("Can get the result now");
break;
}
}
int result = d1.EndInvoke(ar);
Console.WriteLine("result: {0}", result);
code snippet AsyncDelegate/Program.cs
With WaitHandle , you can wait for one signal to occur ( WaitOne() ), multiple objects that all must be
signaled ( WaitAll() ), or one of multiple objects ( WaitAny() ). WaitAll and WaitAny are static members of
the WaitHandle class and accept an array of WaitHandle parameter.
WaitHandle has a SafeWaitHandle property, where you can assign a native handle to an operating
system resource and wait for that handle. For example, you can assign a SafeFileHandle to wait for a
fi le I/O operation to complete, or a custom SafeTransactionHandle as shown in Chapter 23,
“ System.Transactions. ”
www.it-ebooks.info