Gestire la backpressure negli stream reattivi
Gestisca produttori veloci e client WebSocket lenti in WebFlux usando gli operatori di backpressure di Reactor, così gli stream restano stabili sotto carico.
Gestire la backpressure negli stream reattivi è una lezione WebSockets & Real-Time Systems with Spring gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento WebSockets & Real-Time Systems with Spring, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso WebSockets & Real-Time Systems with Spring include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
The Fast Producer, Slow Consumer Problem
A reactive WebSocket may emit market ticks faster than a client can consume them. Without control, buffers grow until memory is exhausted. This mismatch is what backpressure solves.
What Backpressure Means
Backpressure is the consumer telling the producer how much it can handle. In Reactor, the subscriber requests n items; the publisher must not exceed that demand.
Reactor Is Demand-Driven
A reactive Flux built from a cold source naturally honors demand: nothing is produced until requested. The challenge appears with hot, time-driven sources like a price feed that emits regardless of demand.
WebSocketHandler Returns a Mono
In WebFlux a handler wires the outbound Flux into session.send. The framework subscribes and applies the transport's demand for you.
public Mono<Void> handle(WebSocketSession session) {
Flux<String> out = prices.map(p -> session.textMessage(p));
return session.send(out);
}onBackpressureBuffer
Buffer overflow items up to a limit, then take an action. Good when bursts are short.
flux.onBackpressureBuffer(1000,
dropped -> log.warn("dropped {}", dropped),
BufferOverflowStrategy.DROP_OLDEST);onBackpressureDrop
When the consumer is slow, simply drop new items. Ideal for telemetry where only the latest values matter.
flux.onBackpressureDrop(dropped -> metrics.increment("dropped"));onBackpressureLatest
Keep only the most recent item, discarding intermediate ones. Perfect for a live dashboard that shows the current value, not the history.
flux.onBackpressureLatest();Sampling and Throttling
Instead of dropping reactively, reduce the rate up front. sample emits the latest value at a fixed interval, smoothing a firehose into a manageable stream.
flux.sample(Duration.ofMillis(200));Bounding Buffers Everywhere
Unbounded buffers are the silent killer. Always cap buffers and choose a strategy (drop, error, latest) so a stalled client cannot consume the server's heap.
Detecting Overwhelmed Clients
If a client repeatedly triggers drops, it may be too slow for the feed. Consider lowering its update rate, sending deltas, or closing the session with a clear status.
session.close(CloseStatus.create(1011, "client too slow"));Choosing a Strategy
Match the operator to the data:
- Must-not-lose orders →
bufferwith a safe cap, or error - Live metrics/prices →
latestorsample - Best-effort telemetry →
drop
Quick Check
Test your backpressure understanding.
Recap
You tamed reactive streams:
- Backpressure aligns a fast producer with a slow consumer
- Reactor is demand-driven; hot sources need explicit handling
buffer,drop, andlateststrategies suit different datasamplethrottles a firehose at the source- Never leave buffers unbounded; close clients that cannot keep up
Impara WebSockets & Real-Time Systems with Spring con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 12
- Lezioni
- 48
Domande Frequenti
La lezione «Gestire la backpressure negli stream reattivi» è gratuita?
Sì — il testo completo di «Gestire la backpressure negli stream reattivi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso WebSockets & Real-Time Systems with Spring, passa a CoddyKit PRO. Il corso WebSockets & Real-Time Systems with Spring include 4 lezioni in totale.
Cosa imparerò in «Gestire la backpressure negli stream reattivi»?
Gestisca produttori veloci e client WebSocket lenti in WebFlux usando gli operatori di backpressure di Reactor, così gli stream restano stabili sotto carico. Eserciti WebSockets & Real-Time Systems with Spring con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare WebSockets & Real-Time Systems with Spring?
Non è richiesta alcuna esperienza precedente. WebSockets & Real-Time Systems with Spring su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Gestire la backpressure negli stream reattivi»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione WebSockets & Real-Time Systems with Spring?
Sì. Ogni lezione WebSockets & Real-Time Systems with Spring include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Introduzione alla programmazione reattiva
- Handler WebSocket con WebFlux
- Creazione di servizi reattivi in tempo reale
- Gestire la backpressure negli stream reattivi