Cosa limita la concorrenza su larga scala? Spiega contesa, false sharing e backpressure.

Question

IT Interview Practice · Accepted Answer

**Su larga scala, il throughput è limitato meno dal numero di CPU che dalla contesa, dagli effetti di cache e dalle code illimitate — aggiungere thread oltre un certo punto rallenta le cose.** Sia la legge di Amdahl sia la Universal Scalability Law lo prevedono: il costo di coordinamento finisce per dominare.

## Contesa

Quando molti thread si contendono un solo lock o una sola cache line, si serializzano e passano il tempo ad aspettare invece che a lavorare. Secondo la Universal Scalability Law, la contesa più il **costo di coerenza** può far *diminuire* il throughput oltre un numero ottimale di thread.

**Mitigazioni**: sharding/partizionamento dei dati, stato per-thread (thread-local, contatori striped come `LongAdder`), read-write lock o strutture lock-free.

## False sharing

Due variabili indipendenti che per caso stanno sulla **stessa cache line della CPU** fanno sì che i core invalidino a vicenda le proprie cache a ogni scrittura, anche se non toccano mai gli stessi dati — un rallentamento silenzioso e brutale.

```text
cache line (64B): [ counterA | counterB ]  ← due core si palleggiano la line
Soluzione: aggiungi padding così ogni variabile calda possiede la propria line
```

```java
@Contended long counterA;   // la JVM aggiunge padding fino a una cache line separata
```

## Backpressure

Quando i producer superano i consumer, una coda illimitata cresce fino a OOM e la latenza esplode. La **backpressure** segnala ai producer di rallentare: code limitate che si bloccano o rifiutano, controllo di flusso a crediti o `request(n)` dei reactive-streams.

```text
producer ──▶ [coda limitata piena] ──▶ blocca/rifiuta ──▶ il producer rallenta
```

## Perché è importante

Questi sono gli effetti che separano "funziona su 4 core" da "scala a 64". I progetti ingenui sbattono contro un muro: i lock serializzano, le cache line si palleggiano, le code si gonfiano. Fare sharding per ridurre la contesa, aggiungere padding per eliminare il false sharing e usare la backpressure per limitare le code sono le leve che mantengono sani latenza e throughput sotto carico reale.

Contesa

False sharing

Backpressure

Perché è importante

Domande correlate