Free-ebooks-library - Bahar Ali Khan

Exchange and CompareExchange methods, the latter enabling lock-free read-modifywrite
operations, with a little additional coding.
A statement is intrinsically atomic if it executes as a single indivisible instruction on
the underlying processor. Strict atomicity precludes any possibility of preemption.
A simple read or write on a field of 32 bits or less is always atomic. Operations on
64-bit fields are guaranteed to be atomic only in a 64-bit runtime environment, and
statements that combine more than one read/write operation are never atomic:
class Atomicity
{
static int _x, _y;
static long _z;
static void Test()
{
long myLocal;
_x = 3; // Atomic
_z = 3; // Nonatomic on 32-bit environs (_z is 64 bits)
myLocal = _z; // Nonatomic on 32-bit environs (_z is 64 bits)
_y += _x; // Nonatomic (read AND write operation)
_x++; // Nonatomic (read AND write operation)
}
}
Reading and writing 64-bit fields is nonatomic on 32-bit environments because it
requires two separate instructions: one for each 32-bit memory location. So, if thread
X reads a 64-bit value while thread Y is updating it, thread X may end up with a
bitwise combination of the old and new values (a torn read).
The compiler implements unary operators of the kind x++ by reading a variable,
processing it, and then writing it back. Consider the following class:
class ThreadUnsafe
{
static int _x = 1000;
static void Go() { for (int i = 0; i < 100; i++) _x--; }
}
Putting aside the issue of memory barriers, you might expect that if 10 threads concurrently
run Go, _x would end up as 0. However, this is not guaranteed, because a
race condition is possible whereby one thread preempts another in between retrieving
_x’s current value, decrementing it, and writing it back (resulting in an out-of-date
value being written).
Of course, you can address these issues by wrapping the nonatomic operations in a
lock statement. Locking simulates atomicity if consistently applied, but the
Interlocked class provides an easier and faster solution for such simple operations:
class Program
{
static long _sum;
Nonblocking Synchronization | 831
Threading