C# 5.0 Programmer's Reference

Thread-Safe Objects ❘ 503
Other Locking Classes
The .NET Framework provides a few other primitive classes that you can use to
provide locking mechanisms. Usually the lock statement and the Monitor class are
easier to use, so you should use those if possible.
The Mutex class lets a process acquire a lock much as the Monitor class does. One
big difference between Mutex and Monitor is that a Mutex can wait for a named
mutex that is defined systemwide. That means you can use Mutex to coordinate
among threads running in different programs.
The SpinLock structure is like a high-performance Monitor class. Obtaining and
managing locks involves some overhead, so creating and using a Monitor object
can slow a thread down. Instead of creating a Monitor object, when a thread uses
a SpinLock to enter a critical region, it enters a loop and spins until it can acquire
the lock. This can improve performance if the thread will acquire the lock quickly.
If the thread must spin for a long time (more than a few dozen milliseconds), then
its loop will use up more CPU cycles than a Monitor object would, so the SpinLock
will degrade the performance of other threads.
The ReaderWriterLockSlim class is useful if a writer object needs exclusive write
access to a resource and any number of reader objects need nonexclusive read access
to the resource.
The Semaphore class is similar to the Mutex class. The difference is that the
Mutex class allows only one thread to access a critical region at one time, whereas
a Semaphore allows a fixed number of threads to access a critical region at one
time. For example, you could use a Semaphore to allow up to four threads to
access a resource at the same time. Both Mutex and Semaphore let you lock
threads locally within the same program or systemwide.
For more information on these and a few even more exotic synchronization classes,
see “Overview of Synchronization Primitives” at msdn.microsoft.com/library/
ms228964.aspx.
Thread-Safe Objects
An object is thread-safe if it is safe for it and other objects of that class or other classes to run on different
threads at the same time. For example, in the race condition example described earlier, the objects
running in threads A and B were not thread-safe because they tried to read and update the same variable
in an unsafe manner.
If a class accesses only its own instance variables and no other class accesses those variables, then it
is thread-safe.
www.it-ebooks.info