0Pricing
WebSockets & Real-Time Systems with Spring · Leçon

Gérer le contrôle de la pression dans les flux réactifs

Gérez les producteurs rapides et les clients WebSocket lents dans WebFlux avec les opérateurs de contrôle de la pression de Reactor, afin que les flux restent stables sous charge.

Gérer le contrôle de la pression dans les flux réactifs est une leçon WebSockets & Real-Time Systems with Spring gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage WebSockets & Real-Time Systems with Spring, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours WebSockets & Real-Time Systems with Spring comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

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 → buffer with a safe cap, or error
  • Live metrics/prices → latest or sample
  • 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, and latest strategies suit different data
  • sample throttles a firehose at the source
  • Never leave buffers unbounded; close clients that cannot keep up

Questions Fréquemment Posées

La leçon « Gérer le contrôle de la pression dans les flux réactifs » est-elle gratuite ?

Oui — le texte complet de « Gérer le contrôle de la pression dans les flux réactifs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours WebSockets & Real-Time Systems with Spring, passe à CoddyKit PRO. Le cours WebSockets & Real-Time Systems with Spring comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gérer le contrôle de la pression dans les flux réactifs » ?

Gérez les producteurs rapides et les clients WebSocket lents dans WebFlux avec les opérateurs de contrôle de la pression de Reactor, afin que les flux restent stables sous charge. Tu pratiques WebSockets & Real-Time Systems with Spring avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer WebSockets & Real-Time Systems with Spring ?

Aucune expérience préalable n'est requise. WebSockets & Real-Time Systems with Spring sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Gérer le contrôle de la pression dans les flux réactifs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon WebSockets & Real-Time Systems with Spring ?

Oui. Chaque leçon WebSockets & Real-Time Systems with Spring inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Introduction à la programmation réactive
  2. Gestionnaires WebSocket WebFlux
  3. Création de services réactifs en temps réel
  4. Gérer le contrôle de la pression dans les flux réactifs
← Retour à WebSockets & Real-Time Systems with Spring