C# 4 and .NET 4

520 ❘ ChaPTer 20 threAds, tAsks, And synchrOnizAtiOn
}
}
lock (syncRoot)
{
return ++state;
}
code snippet SynchronizationSamples/SharedState.cs
There is, however, a faster way to lock the increment of the state, as shown next.
interlocked
The Interlocked class is used to make simple statements for variables atomic. i++ is not thread-safe.
i++ consists of getting a value from the memory, incrementing the value by 1, and storing the value back
in memory. These operations can be interrupted by the thread scheduler. The Interlocked class provides
methods for incrementing, decrementing, exchanging, and reading values in a thread-safe manner.
Using the Interlocked class is much faster than other synchronization techniques. However, you can use it
only for simple synchronization issues.
For example, instead of using the lock statement to lock access to the variable someState when setting it to
a new value, in case it is null, you can use the Interlocked class, which is faster:
lock (this)
{
if (someState == null)
{
someState = newState;
}
}
code snippet SynchronizationSamples/SharedState.cs
The faster version with the same functionality uses the Interlocked.CompareExchange() method:
Interlocked.CompareExchange(ref someState,
newState, null);
And instead of performing incrementing inside a lock statement:
public int State
{
get
{
lock (this)
{
return ++state;
}
}
}
You can use Interlocked.Increment(), which is faster:
public int State
{
get
{
return Interlocked.Increment(ref state);
}
}
www.it-ebooks.info