In C#, what does “atomic” mean?

Question

I read this in the book C# 6.0 and the .NET 4.6 framework:

“assignments and simple arithmetic operations are not atomic”.

So, what d

Answer 1

An atom is indivisible. Atomic operations are "indivisible" operations, which cannot be divided, e.g., interrupted.

Microprocessors do not execute sequentially, that is, instruction after instruction, just like written in a program. There are external objects, which can change execution flow. A good example are interrupts.

So, you may know the MOV instruction, which is available on pretty much all processors.
Imagine that it is executed by the CPU. a 32-bit value is moved into a 32-bit register.
Now, after 16 bits have been moved, an interrupt request occurs.

• An atomic MOV instruction will not stop but will execute to the end and then the CPU will handle the interrupt
• A MOV instruction that is not atomic will immediately be stopped and the interrupt is executed. The problem is, if the interrupt accessed the register, which was written to by the MOV, the content is unclear because the MOV operation is only half-finished!

Now, on usual processors, MOVs operating on the processor's word size are atomic. If a processor word is 16 bits wide, a 16-bit MOV instruction will be atomic.
However, a 32-bit MOV operation would not be atomic. Such a non-atomic MOV instruction is normally not provided by the instruction set but by some higher-level language as with C's long long or C#'s long. Operations on these data types are not guaranteed to be atomic!

Answer 2

Atomic operations are ones that cannot be interrupted partway through, such as by threading. Take for instance the statement

_value++;

If you have two threads executing this code at once with a starting value of 0, you may have the following

• Thread A reads _value, 0
• Thread A adds 1, 1
• Thread B reads _value, 0
• Thread B adds 1, 1
• Thread A assigns to _value, 1
• Thread B assigns to _value, 1

so now, even though we've called an increment twice, the final value in _value is 1, not the expected 2. This is because increment operators are not atomic.

The function Interlocked.Increment, however, is atomic, so replacing the above code with

Interlocked.Increment(ref _value);

Would solve the given race condition.

EDIT: As a point of etymology, "atomic" usually means "indivisible" - the chemistry term we're familiar with is a misnomer held over from the belief that atoms were indivisible, only for later discoveries to break them down further into subatomic, quark, and quanta levels.