What limits concurrency at scale? Explain contention, false sharing, and backpressure.

Question

IT Interview Practice · Accepted Answer

**scale వద్ద, throughput CPU count కంటే contention, cache effects, మరియు unbounded queues ద్వారా ఎక్కువగా పరిమితం అవుతుంది — ఒక పాయింట్ దాటి threads ను జోడించడం విషయాలను నెమ్మదిగా చేస్తుంది.** Amdahl's మరియు Universal Scalability Law రెండూ దీన్ని అంచనా వేస్తాయి: coordination ఖర్చు చివరికి ఆధిపత్యం వహిస్తుంది.

## Contention

అనేక threads ఒక lock లేదా cache line కోసం పోరాడినప్పుడు, అవి serialize అవుతాయి మరియు పని చేయడానికి బదులుగా వేచి ఉండటానికి సమయం గడుపుతాయి. Universal Scalability Law కింద, contention తో పాటు **coherency cost** ఒక optimal thread count దాటి throughput ను *తగ్గించవచ్చు*.

**Mitigations**: డేటాను shard/partition చేయండి, per-thread state (thread-local, `LongAdder` వంటి striped counters), read-write locks, లేదా lock-free structures.

## False sharing

**అదే CPU cache line** పై కూర్చునే రెండు స్వతంత్ర variables, అవి ఎప్పుడూ అదే డేటాను తాకకపోయినా, ప్రతి write పై cores ఒకదాని caches ను మరొకటి invalidate చేసేలా చేస్తాయి — ఒక నిశ్శబ్ద, క్రూరమైన మందగింపు.

```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 ను అధిగమించినప్పుడు, ఒక unbounded 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
```

## ఇది ఎందుకు ముఖ్యం

ఇవి "works on 4 cores" ను "scales to 64" నుండి వేరు చేసే ప్రభావాలు. Naive designs ఒక గోడను తాకుతాయి: locks serialize అవుతాయి, cache lines thrash అవుతాయి, queues ఉబ్బుతాయి. contention ను తగ్గించడానికి Sharding, false sharing ను చంపడానికి padding, మరియు queues ను పరిమితం చేయడానికి backpressure అనేవి real load కింద latency మరియు throughput ను ఆరోగ్యంగా ఉంచే levers.

Contention

False sharing

Backpressure

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు