Wat begrenst concurrency op schaal? Leg contentie, false sharing en backpressure uit.

Question

IT Interview Practice · Accepted Answer

**Op schaal wordt de throughput minder begrensd door het aantal CPU's dan door contentie, cache-effecten en onbegrensde queues — voorbij een bepaald punt threads toevoegen maakt de zaken trager.** Zowel Amdahl's wet als de Universal Scalability Law voorspellen dit: coördinatiekosten domineren uiteindelijk.

## Contentie

Wanneer veel threads om één lock of cache line vechten, serialiseren ze en besteden tijd aan wachten in plaats van werken. Onder de Universal Scalability Law kunnen contentie plus **coherency cost** de throughput voorbij een optimaal thread-aantal doen *dalen*.

**Mitigaties**: data sharden/partitioneren, per-thread state (thread-local, striped counters zoals `LongAdder`), read-write locks of lock-free structuren.

## False sharing

Twee onafhankelijke variabelen die toevallig op **dezelfde CPU cache line** zitten, zorgen dat cores elkaars caches invalideren bij elke write, ook al raken ze nooit dezelfde data aan — een stille, brute vertraging.

```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

Wanneer producers de consumers voorbijstreven, groeit een onbegrensde queue tot OOM en explodeert de latency. **Backpressure** geeft producers een signaal om af te remmen: begrensde queues die blokkeren of afwijzen, credit-based flow control, of reactive-streams `request(n)`.

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

## Waarom het belangrijk is

Dit zijn de effecten die "werkt op 4 cores" scheiden van "schaalt naar 64." Naïeve ontwerpen lopen tegen een muur: locks serialiseren, cache lines thrashen, queues zwellen op. Sharden om contentie te verminderen, padden om false sharing te doden, en backpressure om queues te begrenzen zijn de hefbomen die latency en throughput gezond houden onder echte belasting.

Contentie

False sharing

Backpressure

Waarom het belangrijk is

Gerelateerde vragen