atomic operations, memory visibility, અને memory barriers સમજાવો.

Question

IT Interview Practice · Accepted Answer

**atomic operation અવિભાજ્ય રીતે પૂરું થાય છે — કોઈ બીજો thread અડધું-થયેલું state જોતું નથી; memory visibility એ છે કે એક thread ના writes બીજા દ્વારા જોવાય છે કે નહીં; memory barriers ordering લાગુ કરે છે જેથી તે writes visible બને.** Locks એકમાત્ર ચિંતા નથી — memory model છે.

## Atomicity

atomic op (દા.ત. `fetch_add`, compare-and-swap) એક અવિભાજ્ય step તરીકે execute થાય છે, તેથી કોઈ race તેને વિભાજિત કરતું નથી. Hardware અને language counters અને flags માટે full lock વગર atomics પૂરાં પાડે છે.

```java
AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();  // atomic read-modify-write, no lock
```

## Visibility અને reordering

આધુનિક CPUs અને compilers speed માટે values ને registers માં cache કરે છે અને instructions ને reorder કરે છે. તેથી એક thread માંનું write store buffer માં બેસી શકે, બીજાં માટે અદૃશ્ય, અને operations ક્રમ બહાર દેખાઈ શકે.

```java
// Without 'volatile', thread B may loop forever:
volatile boolean ready = false;  // volatile → writes are visible + ordered
// Thread A: data = 42; ready = true;
// Thread B: while (!ready) {}  then read data
```

## Memory barriers

**barrier** (fence) એ એક instruction છે જે તેની આરપાર reordering અટકાવે છે અને memory ને flush/load કરે છે, ordering ની ખાતરી આપે છે. `volatile`, `synchronized`, અને atomics યોગ્ય barriers દાખલ કરે છે જેથી happens-before સંબંધ ધરે: A એ release કરતાં પહેલાં જે લખ્યું, તે B acquire કર્યા પછી જુએ છે.

## આ શા માટે મહત્વનું છે

એકલી atomicity પૂરતી નથી — visibility ની ખાતરીઓ વગર યોગ્ય રીતે-locked value પણ stale વંચાઈ શકે છે. આ સમજાવે છે કે `volatile` કેમ અસ્તિત્વમાં છે, double-checked locking કેમ સૂક્ષ્મ છે, અને lock-free code ને કાળજીપૂર્વકની memory-ordering પસંદગીઓ કેમ જોઈએ છે. તે "મારી machine પર કામ કરે છે" અને વાસ્તવિક multi-core hardware પર સાચું, વચ્ચેનો ફરક છે.

Atomicity

Visibility અને reordering

Memory barriers

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો