lock-free programming மற்றும் CAS என்றால் என்ன? ABA problem-ஐயும் அதை எப்போது பயன்படுத்துவது என்பதையும் விளக்குங்கள்.

Question

IT Interview Practice · Accepted Answer

**Lock-free programming ஆனது mutexes இல்லாமல் threads-ஐ ஒருங்கிணைக்கிறது, atomic compare-and-swap (CAS) loops-ஐப் பயன்படுத்தி, எனவே மற்றவை தேங்கினாலும் குறைந்தபட்சம் ஒரு thread எப்போதும் முன்னேற்றம் அடைகிறது.** ஒரு lock-ஐ வைத்திருக்கும் மற்றொன்றால் எந்த thread-ம் block செய்யப்பட முடியாது.

## CAS

**Compare-and-swap** ஆனது ஒரு location-ஐ ஒரு புதிய value-க்கு atomic-ஆக அமைக்கிறது, அது இன்னும் எதிர்பார்க்கப்பட்ட பழைய value-ஐ வைத்திருந்தால் மட்டுமே; இல்லையெனில் அது தோல்வியடைந்து நீங்கள் மீண்டும் முயற்சிக்கிறீர்கள். இது lock-free stacks, queues, மற்றும் counters-க்குப் பின்னால் உள்ள primitive ஆகும்.

```text
CAS(addr, expected, new):
  if *addr == expected: *addr = new; return true   # atomic, indivisible
  else: return false
```

```java
// Lock-free increment via CAS retry loop
int old, next;
do {
    old  = value.get();
    next = old + 1;
} while (!value.compareAndSet(old, next));  // retry if someone else won
```

## ABA problem

CAS ஆனது value இன்னும் எதிர்பார்க்கப்பட்டதுதானா என்பதை மட்டுமே சரிபார்க்கிறது — அது ஒருபோதும் மாறவில்லை என்பதை அல்ல. உங்கள் read மற்றும் CAS-க்கு இடையில் அது A → B → A என்று சென்றால், CAS வெற்றிபெறுகிறது ஆனால் உலகம் உங்களுக்குக் கீழே நகர்ந்துவிட்டது (எ.கா. ஒரு free-செய்யப்பட்டு-மீண்டும்-பயன்படுத்தப்பட்ட node).

```text
Thread 1: read A ............... CAS(A→X) succeeds ✗ (but list changed!)
Thread 2:      pop A, push B, push A again
```

**சரிசெய்தல்**: pointer-ஐ ஒரு version counter உடன் இணையாக்குங்கள் (`AtomicStampedReference`, tagged pointers), எனவே A-with-tag-1 ≠ A-with-tag-2, அல்லது memory safety-க்காக hazard pointers / epoch reclamation-ஐப் பயன்படுத்துங்கள்.

## அதை எப்போது பயன்படுத்துவது

- lock contention ஆதிக்கம் செலுத்தும், அல்லது ஒரு thread ஒருபோதும் block ஆகக்கூடாத (real-time, signal handlers) hot, fine-grained shared state-க்கு (counters, single-producer queues) **பயன்படுத்துங்கள்**.
- இயல்புநிலையாக **தவிர்க்கவும்**: இதைச் சரியாகப் பெறுவது கடினம், ABA மற்றும் memory-ordering bugs-ஐ அறிமுகப்படுத்துவது எளிது, மேலும் குறைந்த contention-இன் கீழ் ஒரு நல்ல mutex-ஐ விட பெரும்பாலும் வேகமானது அல்ல.

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

Lock-free structures ஆனது progress உத்தரவாதங்களைக் கொடுத்து deadlock மற்றும் priority inversion-ஐத் தவிர்க்கின்றன, ஆனால் correctness அளவுகோல் உயர்ந்தது. CAS, ABA, மற்றும் reclamation problem-ஐ அறிவது நீங்கள் memory-model level-இல் நியாயப்படுத்த முடியும் என்பதைக் குறிக்கிறது — மேலும், முக்கியமாக, அதை எப்போது நோக்கிச் செல்ல *வேண்டாம்* என்பதை அறிவது.

CAS

ABA problem

அதை எப்போது பயன்படுத்துவது

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

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