atomic operations, memory visibility, மற்றும் memory barriers-ஐ விளக்குங்கள்.

Question

IT Interview Practice · Accepted Answer

**ஒரு atomic operation பிரிக்க முடியாத வகையில் நிறைவடைகிறது — வேறு எந்த thread-ம் ஒரு பாதி-முடிந்த நிலையைப் பார்ப்பதில்லை; memory visibility என்பது ஒரு thread-இன் writes மற்றொன்றால் பார்க்கப்படுகிறதா என்பது; memory barriers ஆனது அந்த writes தெரியும்படி ordering-ஐ கடைபிடிக்கின்றன.** Locks மட்டுமே கவலை அல்ல — memory model தான்.

## Atomicity

ஒரு atomic op (எ.கா. `fetch_add`, compare-and-swap) ஒரு பிரிக்க முடியாத படியாக execute ஆகிறது, எனவே எந்த race-ம் அதைப் பிரிப்பதில்லை. Hardware மற்றும் language ஆனது ஒரு முழு lock இல்லாமல் counters மற்றும் flags-க்கு atomics-ஐ வழங்குகின்றன.

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

## Visibility மற்றும் reordering

நவீன CPUs மற்றும் compilers ஆனது values-ஐ registers-இல் cache செய்து வேகத்திற்காக instructions-ஐ மறுவரிசைப்படுத்துகின்றன. எனவே ஒரு 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) என்பது தன்னைக் கடந்து reordering-ஐத் தடுக்கும் மற்றும் memory-ஐ flush/load செய்யும் ஒரு instruction ஆகும், ordering-ஐ உறுதி செய்கிறது. `volatile`, `synchronized`, மற்றும் atomics சரியான barriers-ஐ செருகுகின்றன, எனவே ஒரு happens-before உறவு நிலைத்திருக்கிறது: release செய்வதற்கு முன் A எழுதியதை, acquire செய்த பிறகு B பார்க்கிறது.

## இது ஏன் முக்கியம்

Atomicity மட்டும் போதாது — visibility உத்தரவாதங்கள் இல்லாமல் சரியாக lock செய்யப்பட்ட ஒரு value இன்னும் பழையதாகப் படிக்கப்படலாம். `volatile` ஏன் உள்ளது, double-checked locking ஏன் நுட்பமானது, மேலும் lock-free code-க்கு ஏன் கவனமான memory-ordering தேர்வுகள் தேவை என்பதை இது விளக்குகிறது. இது "என் machine-இல் வேலை செய்கிறது"-க்கும் உண்மையான multi-core hardware-இல் சரியானது-க்கும் இடையிலான வித்தியாசம்.

Atomicity

Visibility மற்றும் reordering

Memory barriers

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்