scale-இல் concurrency-ஐ எது வரம்பிடுகிறது? contention, false sharing, மற்றும் backpressure-ஐ விளக்குங்கள்.

Question

IT Interview Practice · Accepted Answer

**scale-இல், throughput ஆனது CPU எண்ணிக்கையால் அல்ல, contention, cache effects, மற்றும் வரம்பற்ற queues-ஆல் அதிகம் வரம்பிடப்படுகிறது — ஒரு புள்ளியைத் தாண்டி threads-ஐச் சேர்ப்பது விஷயங்களை மெதுவாக்குகிறது.** Amdahl-இன் மற்றும் Universal Scalability Law இரண்டும் இதைக் கணிக்கின்றன: coordination செலவு இறுதியில் ஆதிக்கம் செலுத்துகிறது.

## Contention

பல threads ஒரு lock அல்லது cache line-க்காகப் போராடும்போது, அவை serialize ஆகி வேலை செய்வதற்குப் பதிலாக காத்திருக்க நேரத்தைச் செலவழிக்கின்றன. Universal Scalability Law-இன் கீழ், contention மற்றும் **coherency செலவு** ஒரு optimal thread எண்ணிக்கையைத் தாண்டி throughput-ஐ *குறையச்* செய்யக்கூடும்.

**தணிப்புகள்**: shard/partition data, per-thread state (thread-local, `LongAdder` போன்ற striped counters), read-write locks, அல்லது lock-free structures.

## False sharing

**ஒரே CPU cache line**-இல் அமரும் இரண்டு சுயாதீன variables ஆனது cores-ஐ ஒவ்வொரு write-இலும் ஒன்றையொன்று caches-ஐ invalidate செய்ய வைக்கின்றன, அவை ஒருபோதும் ஒரே data-ஐத் தொடாவிட்டாலும் — ஒரு அமைதியான, கொடூரமான மந்தநிலை.

```text
cache line (64B): [ counterA | counterB ]  ← two cores ping-pong the line
Fix: pad so each hot variable owns its own line
```

```java
@Contended long counterA;   // JVM pads to a separate cache line
```

## Backpressure

producers ஆனது consumers-ஐ விஞ்சும்போது, ஒரு வரம்பற்ற queue OOM வரை வளர்ந்து latency வெடிக்கிறது. **Backpressure** ஆனது producers-க்கு மெதுவாகச் செல்லும்படி சமிக்ஞை செய்கிறது: block அல்லது reject செய்யும் bounded queues, credit-based flow control, அல்லது reactive-streams `request(n)`.

```text
producer ──▶ [bounded queue full] ──▶ block/reject ──▶ producer slows
```

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

இவை "4 cores-இல் வேலை செய்கிறது"-ஐ "64-க்கு scale ஆகிறது"-இலிருந்து பிரிக்கும் விளைவுகள். naive designs ஒரு சுவரில் மோதுகின்றன: locks serialize ஆகின்றன, cache lines thrash ஆகின்றன, queues வீங்குகின்றன. contention-ஐக் குறைக்க sharding, false sharing-ஐ அழிக்க padding, மற்றும் queues-ஐ வரம்பிட backpressure ஆகியவை உண்மையான load-இன் கீழ் latency மற்றும் throughput-ஐ ஆரோக்கியமாக வைத்திருக்கும் கருவிகள்.

Contention

False sharing

Backpressure

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

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