Atomic Operations in OS

April 25, 2025

Atomic Operations

Atomic Operations in OS are a fundamental concept in operating systems that ensure certain operations are completed without any interruption. On this page, we will discuss what Atomic Operations in Operating System are and how they help us. Atomic operations are the operations that execute as a single unified operation.

These operations either complete entirely or do not happen at all, ensuring data consistency in multi threaded environments. They are essential for preventing race conditions and maintaining synchronization among concurrent processes.

Atomic Operations

Atomic operations are the operations that execute as a single unified operation. In simple terms, when an atomic operation is being executed, no other process can read through or modify the data that is currently used by atomic operation.

Atomic operations are used in concurrent programming where program operations run independently, without being interleaved by any other operation. These operations are used in many operating systems which implements parallel processing.

Type of Atomic Operations

Listed below are some of the atomic operations which are being used regularly:

  1. Fine-grained atomic operations (Small Atomic Operation):  These operations can be implemented without any interruptions. For example, loading and storing registers.
  2. Coarse-grained atomic operations (Large Atomic Operations): These include a series of fine grained operations which cannot be interrupted. For example a call of a synchronized method in JAVA.
Types of Atomic operations in OS

Prepare for Interview with us:

Top 100 Codes
Top 150 Notout Qs
Learn via Videos

Priority Scheduling

CPU Scheduling

FCFS Scheduling

Preemptive Scheduling

Advantage and Disadvantage of Atomic Operations

AdvantageDisadvantage
Ensures consistency of shared data in concurrent environmentsCan be complex to design correctly for all use cases
Avoids context switching and locking overhead of mutexes/semaphoresMay cause performance bottlenecks due to CPU level contention
Simple and fast low level primitives for synchronizationLimited in scope only works for simple operations (e.g., increment/decrement)
Reduces the chance of deadlocks compared to traditional locking mechanismsNot suitable for complex critical sections
Widely supported by modern hardware architecturesImplementation may vary across platforms/hardware
Useful in real time systems where low latency is criticalBusy waiting (spinlocks) can waste CPU cycles if not carefully managed

Example of Atomic Operation

  • Consider a process in which the value of temp is to be fetched and incremented by 1.
  • Let initially, the value of temp be 0.
  • Now after the execution of the process the value of temp is increased by 1 and it becomes equal to 1.
  • However, now this processes is pre-empted and a new process is initiated, which also use the value of temp and increase its value by 5.
  • Now, the value of temp becomes 6 as the initial value was 1, which is then increased by 5.
  • After, completion of this process, when the first process starts its execution again, the value of temp becomes 5+1=6.
  • However, the expected result, in this case, was 1+1=2. Hence, a wrong solution is generated.
  • Nevertheless, in the case of atomic operations, the value of temp can neither be read nor modified, thereby ensuring the accuracy of results.

“Atomic” comes from Latin and means “indivisible”. The increment operator is not indivisible; it has 3 separate parts:

  • Load value from memory into register.
  • Increment register.
  • Store value from register back into memory.

So, for example, if you have two threads that try to increment a number, if
the number starts from zero you could get either 1 or 2 as a result, at
random. You get 1 when an interleaving similar to the below happens:

  1. Thread 1 loads zero into a register.
  2. Thread 2 loads zero into a register.
  3. Thread 1 increments register (0 -> 1).
  4. Thread 2 increments register (0 -> 1).
  5. Thread 1 writes the value “1” into memory.
  6. Thread 2 writes the value “1” into memory.

In many languages there are special variants of the increment operator that are atomic. Normally they are supported by the hardware itself (this is harder than it sounds; AFAIK it’s not just the CPU, but the caches and main memory and everything needs to work together to provide this). You
should either use those, or manual synchronization (say, a lock so that the increments run start to finish, and others are prohibited from starting while another one is running).

Closing remarks

Atomic operations in operating systems play a critical role in ensuring data consistency and synchronization in multi threaded environments. By executing operations as indivisible units, they help prevent race conditions and maintain process integrity. While atomic operations are efficient and reduce the likelihood of deadlocks, they can be complex to design and may introduce performance bottlenecks in certain cases. Despite these challenges, they remain essential for concurrent programming, particularly in real time systems and hardware architectures that require low latency operations.

FAQs

Atomic operations execute as indivisible units, ensuring they are completed entirely or not at all, with no interruptions during their execution.

They ensure that shared data is not altered by other processes during execution, maintaining consistency and avoiding conflicts in multi-threaded environments.

Fine grained atomic operations are small and uninterrupted, while coarse grained operations involve a series of fine grained tasks executed as a whole without interruptions.

Atomic operations offer data consistency and reduce the risk of deadlocks, but they can be challenging to implement and may cause performance issues in certain situations.