Interlocked Class in c# Threading

Introduction

In this article I am going to describe Non-Blocking Synchronization Constructs. There ae two Non-Blocking Synchronization Constructs:

• Interlocked
• volatile

Note : For a description of volatile, please read my article "Volatile keyword in C# Threading"; see http://www.c-sharpcorner.com/UploadFile/1d42da/volatile-keyword-in-C-Sharp-threading/

Interlocked class

Namespace : System.Threading

Assembly : mscorlib (in mscorlib.dll)

Remarks

The methods of this class help protect against errors that can occur when the scheduler switches contexts while a thread is updating a variable that can be accessed by other threads, or when two threads are executing concurrently on separate processors. The members of this class do not throw exceptions.

The Interlocked class belongs to the System.Threading namespace. When two threads try to update same variables or when two threads are concurrently executing there are chances of many error occurrences and incorrect data updates.
In those situations, the Interlocked class and its methods are very helpful to manipulate variables accessible by one or more threads without throwing any error or exception. Methods provided by the Interlocked class are listed below.

• Increment : Used to increment a variable's value and store its result. Int32 and Int64 integers are its legal parameters.
• Decrement : Used to decrement a variable's value and store its result. Int32 and Int64 integers are its legal parameters.
• Exchange : Used to exchange values between variables. This method has seven overloaded versions based on the different types it can accept as its parameter.
• CompareExchange : Compares two variables and stores the result of comparison in another variable. This method also has seven overloaded versions.
• Add : Adds two integer variables and updates the result in the first integer variable. It is used to add integers of type Int32 as well as Int64.
• Read : Reads an integer variable. It is used to read an integer of type Int64.

We know that variables that increment and decrement have their own framework class, the Interlocked class. This class provides simple thread-safe methods to do some common tasks with variables. The Increment and Decrement methods add or subtract 1 from a variable. These methods can be considered "atomic". This means that the operating system will consider the entire operation as one not allowing other threads to interrupt their execution.

The Increment and Decrement methods increment or decrement a variable and store the resulting value in a single operation. On most computers, incrementing a variable is not an atomic operation, requiring the following steps.

1. Load a value from an instance variable into a register.
2. Increment or decrement the value.
3. Store the value in the instance variable.

If you do not use Increment and Decrement, a thread can be preempted after executing the first two steps. Another thread can then execute all three steps. When the first thread resumes execution, it overwrites the value in the instance variable, and the effect of the increment or decrement performed by the second thread is lost.

Take a look at the following which ensures that the computer will not interrupt the incrementing or decrementing of the variable a:

int a=1;
a = Interlocked.Increment;
a = Interlocked.Decrement;

There are two additional methods in the Interlocked class, Exchange and CompareExchange. Let's take a closer look at these two.

The Exchange method atomically exchanges the values of the specified variables. The second value could be a hard coded value or a variable. Don't let the name of the method, Exchange, confuse you though. Only the first variable ed in the first parameter will be replaced by the second. The method won't really exchange the values of two.