Which C# Operations Guarantee Atomicity?

Understanding Atomicity in C# Operations

In programming, atomicity refers to the ability of an operation to be completed without interruption or interference. In C#, some operations are guaranteed to be atomic, while others may not. Here's a systematic guide to determine the atomicity of operations in C#:

Atomic Operations

For most scenarios, you can rely on the following guidelines for atomic operations:

• Reads and writes to 32-bit value types: Operations on 32-bit intrinsic value types (e.g., int, uint, float) are atomic.
• Reference assignment: Assigning a reference to an object is an atomic operation.

Example:

int x;
x = 10; // atomic assignment of 32-bit value type

Non-Atomic Operations

Some value types and operations in C# are not guaranteed to be atomic. These include:

• 64-bit value types: Operations on 64-bit value types (e.g., long, ulong) may not be atomic.
• Floating-point value types: Operations on floating-point value types (e.g., decimal, double) are not atomic.
• Complex operations: Operations involving multiple steps, such as arithmetic expressions or method calls, may not be atomic.

Example:

decimal d;
d = 10m; // not atomic assignment of 64-bit value type

Rule of Thumb

As a general rule, any operation that can change the state of multiple variables simultaneously is likely to be non-atomic. Conversely, operations confined to a single variable are often atomic.

The above is the detailed content of Which C# Operations Guarantee Atomicity?. For more information, please follow other related articles on the PHP Chinese website!