Tagged articles
backpressure
63 articles · Page 1 of 1
The article explains why scaling a single agent to thousands requires load-testing capacity, releasing resources during waits, using bounded queues and backpressure, enforcing tenant quotas and isolation, handling cancellations without duplicating external actions, and validating failure scenarios like cold starts and process crashes.
Agent orchestrationKubernetesMulti-tenancy
0 likes · 9 min read


ITPUBSep 30, 2026 · Artificial Intelligence
This article details a production-grade architecture for handling high concurrency in AI agent systems, covering real load estimation, admission control with bounded queues, async task processing, hierarchical concurrency budgets for models and tools, resource isolation via bulkheads, idempotency for state consistency, graded degradation strategies, and observability-driven capacity planning.
AI agentsCircuit BreakerConcurrency Budget
0 likes · 18 min read

This article argues that true system scaling requires end-to-end capacity planning across ingress, task processing, dependencies, and recovery—not merely adding instances—and shows how to translate business growth into workload models, manage backpressure, set per-link capacity budgets, validate with realistic load tests, and balance cost against performance.
Auto ScalingCost Optimizationbackend architecture
0 likes · 24 min read

A comprehensive guide to replacing RestTemplate with Spring WebClient for high-concurrency HTTP calls, covering connection pool isolation per downstream, three-layer timeout strategy, retry-with-backoff filtering, Resilience4j circuit breaker integration, ExchangeFilterFunction for logging/auth/tracing, and memory-safe streaming with backpressure.
Circuit BreakerNettyReactive Programming
0 likes · 29 min read


ITPUBSep 15, 2026 · Backend Development
This article dissects a real interview challenge: designing a thread pool to send 10 million SMS messages in one hour. It explains why Executors is dangerous, how to calculate initial thread counts using the golden formula for I/O-bound tasks, why dynamic tuning with monitoring matters, and how CallerRunsPolicy provides natural backpressure in batch scenarios. It also covers reliability patterns like persistence, acknowledgments, and compensation tasks to prevent data loss on crashes.
CallerRunsPolicyInterviewThreadPoolExecutor
0 likes · 10 min read

This article details a systematic approach to diagnosing and resolving CPU and memory spikes when an Agent processes large document batches, covering backpressure propagation, concurrency budgeting, runtime profiling, and pipeline design to prevent OOM kills and throttling.
AgentCPU spikeGo
0 likes · 23 min read

StarRocks introduces AI Functions that let SQL directly call LLMs for generation, classification, extraction, and embedding, integrating model inference into the query optimizer and pipeline execution engine with async dual-pipeline architecture, backpressure, and cost-based optimization to reduce unnecessary calls and manage latency.
AI FunctionLLM inferenceSQL execution engine
0 likes · 25 min read

This article details replacing sidecar log collectors with node-level DaemonSets in Kubernetes, covering resource cost analysis, declarative LogPipeline CRD design, controller implementation, backpressure handling, capacity planning, and production verification steps for enterprise-scale log collection.
CRDDaemonSetFluent Bit
0 likes · 58 min read

Sending 10 million marketing SMS within an hour forces careful thread‑pool design: avoid unbounded queues that cause OOM, choose a bounded ThreadPoolExecutor, dynamically tune core/max sizes, use CallerRunsPolicy for natural back‑pressure, and add persistence and compensation mechanisms to guarantee reliability.
Java ConcurrencyOOM preventionThreadPoolExecutor
0 likes · 8 min read

This article analyzes why naïve goroutine usage fails in high‑throughput microservices, outlines five common concurrency pitfalls, and walks through a complete production‑grade Go pipeline—covering worker pools, semaphores, fan‑out/fan‑in, back‑pressure, error classification, observability, and step‑by‑step code implementation for an order‑processing service.
ConcurrencyGoObservability
0 likes · 29 min read

Spring WebFlux replaces the thread‑per‑request model of Spring MVC with an event‑loop, non‑blocking architecture that dramatically reduces memory and CPU usage, supports back‑pressure, streaming, and GraalVM native images, making it ideal for high‑concurrency microservices while acknowledging its learning curve and debugging challenges.
GraalVMJavaReactive Programming
0 likes · 18 min read

The article explains how Spring WebFlux replaces the thread‑per‑request model with an event‑loop, non‑blocking I/O and reactive streams, offering higher resource efficiency, built‑in back‑pressure, and better support for real‑time data, while also discussing its drawbacks and when virtual threads may be a viable alternative.
R2DBCReactive ProgrammingSpring WebFlux
0 likes · 18 min read

An online gateway crashed despite low CPU and memory because its one‑connection‑one‑thread BIO model exhausted threads, prompting a deep dive into thread‑pool limits, epoll, Reactor patterns, Proactor, and back‑pressure, showing how each evolution decouples connections from resource consumption to achieve million‑QPS scalability.
BIOEpollReactor
0 likes · 18 min read

The article explains how a ten‑million‑QPS messaging system can shift from reactive fire‑fighting to proactive backlog prevention by using long‑, mid‑, and short‑term defense layers, capacity planning, predictive scaling, backpressure, and regular chaos engineering to eliminate user‑visible latency.
Message Queuebacklog preventionbackpressure
0 likes · 19 min read

The article analyzes why single‑threaded message consumption hits processing, I/O/CPU mismatch, and fault‑tolerance limits, then walks through a step‑by‑step evolution—pull/worker split, key‑based routing, sliding‑window offset commits, backpressure, and multi‑layer parallelism—to achieve stable ten‑million‑QPS throughput.
Message Queuebackpressureconsumer parallelism
0 likes · 22 min read

The article analyses how synchronous Kafka producer calls block business threads on ACK, limiting throughput, and shows that moving to asynchronous sending with the Accumulator decouples submission from confirmation, unlocking batch, compression, and back‑pressure mechanisms that enable stable operation at tens of millions of QPS.
Kafkaasynchronousbackpressure
0 likes · 21 min read

This comprehensive guide explains how Spring Boot 3 + WebFlux can handle massive concurrent API traffic by leveraging event‑loop I/O, Reactive Streams back‑pressure, and a layered architecture that separates ingestion, processing, storage, and dispatch, while covering pitfalls, performance tuning, observability, and production‑grade best practices.
SSEWebFluxWebSocket
0 likes · 46 min read

This guide explains why traditional Spring MVC struggles under high concurrency, introduces Spring WebFlux’s asynchronous non‑blocking model, compares its performance to MVC, walks through core reactive concepts, shows practical code for controllers, functional endpoints, R2DBC integration, backpressure, scheduling, SSE, gateway usage, and real‑world benchmarking results.
R2DBCReactive ProgrammingSSE
0 likes · 17 min read

This article explains what backpressure is, why Node.js services silently run out of memory, and provides practical streaming and bounded‑concurrency patterns with code examples to keep memory usage stable under load.
Node.jsOOMbackpressure
0 likes · 10 min read

This guide enumerates ten frequent traps encountered when streaming JSON in Node.js—such as assuming one chunk per object, UTF‑8 split issues, missing newline delimiters, back‑pressure overload, and handling of large numbers—and presents reliable patterns like using NDJSON framing, StringDecoder, pipeline, and proper error handling to avoid data loss and memory spikes.
JSONNDJSONNode.js
0 likes · 13 min read

This article presents a production‑grade Flink ClickHouse sink that solves common pain points such as lack of size‑based batching, static table schemas, and distributed‑table latency by introducing data‑size batching, dynamic table routing, local‑table writes, load‑balanced node discovery, back‑pressure queues, dual‑trigger flush, and recursive retry with node exclusion, all integrated with Flink checkpoint semantics for at‑least‑once guarantees.
ClickHouseDynamic ShardingFlink
0 likes · 25 min read

This article explains the fundamentals of network flow control, compares TCP‑based and credit‑based backpressure in Flink, walks through buffer pool interactions, and shows why dynamic backpressure cannot fully replace static rate limiting in real‑world streaming pipelines.
Buffer ManagementCredit-basedFlink
0 likes · 15 min read

This article explains Spark Streaming's rate control mechanisms, covering static limits, the dynamic back‑pressure feature introduced in Spark 1.5, the PID‑based estimator, RPC communication, and how Guava's token‑bucket RateLimiter enforces the calculated thresholds to ensure stability and optimal throughput.
RateControlSparkbackpressure
0 likes · 13 min read

This article explains the concept of backpressure, its implementation in Spring WebFlux, and presents practical strategies—including buffering, dropping, latest, and error handling—along with code samples to help developers manage data flow efficiently in reactive backend applications.
BackendFluxJava
0 likes · 11 min read

During high‑traffic spikes, traditional servlet‑based services often crash due to thread‑pool exhaustion, while reactive systems using Reactor can still fail if backpressure is ignored; this article explains the pitfalls, compares models, and provides practical backpressure solutions such as dynamic rate limiting, bounded buffering, and circuit breaking.
JavaReactive ProgrammingReactor
0 likes · 11 min read

During high‑traffic spikes, traditional servlet thread‑pool systems often collapse, but simply switching to Reactor isn’t enough; without proper backpressure control you’ll still face OOM and outages—this article explains why backpressure matters and offers practical dynamic rate‑limiting, bounded buffering, and circuit‑breaker solutions.
Reactive ProgrammingSpring Reactorbackpressure
0 likes · 12 min read

This article introduces the concept of streams, explains the Web Streams API and its ReadableStream component, details constructors, methods, queuing strategies, back‑pressure handling, BYOB and byte streams, and provides practical code examples and usage scenarios for modern web development.
Front-endReadableStreamWeb Streams API
0 likes · 20 min read

This article explains the concept of data streams, compares pull and push processing models, discusses flow‑control and backpressure mechanisms, evaluates queue choices, and details the core Reactive Streams interfaces (Publisher, Subscriber, Subscription) with example code and references to popular libraries.
PublisherReactive StreamsSubscriber
0 likes · 7 min read

This article explains Flink’s internal data abstraction and transfer mechanisms, detailing how data moves between operators via network buffers, the role of ByteBuffer and NetworkBufferPool, the serialization process, Netty integration, and credit‑based flow control to handle backpressure.
Credit-based Flow ControlFlinkNetwork Buffers
0 likes · 10 min read

This article reviews the fundamentals of token‑bucket rate limiters, identifies precision, cascading compensation, and TCP‑loss sensitivity issues, and details two major improvements—port‑loan backpressure and the Carousel algorithm—while outlining future directions for more reliable network traffic shaping.
DPDKbackpressurecarousel algorithm
0 likes · 14 min read

This article introduces RxJava as a reactive functional programming framework based on the observer pattern, explains its core concepts, stream types, a wide range of operators, backpressure strategies, and demonstrates its practical use for data migration between MongoDB and MySQL.
JavaReactive ProgrammingRxJava
0 likes · 22 min read

This article explains Flink's fundamental checkpoint mechanism, its coupling with backpressure, and how the introduction of Unaligned Checkpoint in Flink 1.11 decouples checkpointing from backpressure to improve latency and resource utilization in high‑backpressure streaming jobs.
FlinkUnaligned Checkpointbackpressure
0 likes · 14 min read

This article explains how to use Flink's Web UI, Kafka metrics, and YARN monitoring to observe performance, diagnose backpressure, and set alert thresholds, providing code examples and practical tips for reliable stream processing in production environments.
FlinkKafkaPerformance Monitoring
0 likes · 9 min read

This article compiles a comprehensive list of common production problems encountered with Apache Flink, covering cluster sizing, checkpoint failures, backpressure analysis, resource allocation, deployment errors, UDF definitions, data skew, Kafka configurations, and provides detailed troubleshooting steps and best‑practice recommendations.
Apache FlinkKafkaUDF
0 likes · 39 min read

This article provides an extensive technical guide to Apache Flink, covering its exactly‑once consumption guarantees, checkpoint and two‑phase commit mechanisms, differences from Spark, state backends, watermark handling, time semantics, window joins, CEP, backpressure, architecture layers, deployment, resource management, and common operational issues.
CEPFlinkWatermark
0 likes · 77 min read

This article provides a comprehensive guide on optimizing Flink checkpoints, diagnosing and alleviating backpressure, and fine‑tuning memory configurations—including process, heap, off‑heap, managed, and network memory—to improve job stability and performance in large‑scale streaming applications.
FlinkMemory TuningStateBackend
0 likes · 25 min read

This article describes a lightweight, resource‑efficient log collection solution that combines Filebeat agents, optional Logstash aggregation, and Kafka transport, detailing configuration choices, meta‑persistence, back‑pressure mechanisms, monitoring setup, and deployment architecture for reliable at‑least‑once delivery.
Log CollectionLogstashOperations
0 likes · 14 min read

This article explains Flink's memory architecture, covering on‑heap and off‑heap memory concepts, garbage collection, allocation strategies, memory segments, buffers, the memory manager, and how network transmission and back‑pressure are handled to achieve efficient streaming processing.
FlinkOff‑Heapbackpressure
0 likes · 20 min read

This article explains the concepts and background of network flow control, compares static rate limiting with dynamic feedback backpressure, describes TCP's sliding‑window mechanism, and details how Flink implements both TCP‑based and credit‑based backpressure to handle mismatched upstream‑downstream speeds in streaming applications.
Credit-basedFlinkNetwork Flow Control
0 likes · 16 min read


ByteFEAug 4, 2021 · Fundamentals
This article provides an in-depth exploration of JavaScript's Streams API, covering core concepts like readable/writable/transform streams, backpressure, and practical applications such as video processing and data compression.
Async ProgrammingBrowser APIsJavaScript
0 likes · 15 min read

This article compiles classic production problems encountered with Apache Flink, covering cluster sizing, checkpoint failures, backpressure diagnosis, client submission errors, resource allocation on YARN, and PyFlink UDF definitions, providing step‑by‑step troubleshooting methods and practical recommendations.
Flinkbackpressurecheckpoint
0 likes · 18 min read

This article dissects Node.js Readable streams, explaining their initialization, internal state management, the distinction between flowing and paused modes, and how back‑pressure is handled, all illustrated with real source‑code examples and diagrams.
JavaScriptNode.jsReadable Stream
0 likes · 39 min read

This article explains the fundamentals of Node.js streams, including basic concepts, stream types, pipe and pipeline usage, handling backpressure, and demonstrates how async iterators can simplify stream processing with detailed code examples and visual animations.
Async IteratorNode.jsPipeline
0 likes · 26 min read

This article explains why Spark Streaming introduced backpressure, how the dynamic rate‑control mechanism works, and provides a detailed walkthrough of the relevant source code, including the RateController class, its registration, and the execution flow that adjusts ingestion rates to match processing capacity.
RateControllerRateLimiterSpark
0 likes · 14 min read

This article explains how reactive programming, introduced by Microsoft in 2009 and adopted by Java through frameworks like RxJava and Spring Reactor, addresses high‑concurrency server‑side challenges, clarifies concepts such as backpressure, and compares Reactor with RxJava for modern backend engineers.
ConcurrencyJavaRxJava
0 likes · 13 min read

This article explains how reactive programming, introduced by Microsoft in 2009 and adopted by Java through Spring Reactor and RxJava, addresses high‑concurrency server‑side challenges by using event‑driven, back‑pressure‑aware streams, and compares the key differences between Reactor and RxJava.
Java ConcurrencyRxJavaSpring Reactor
0 likes · 12 min read

This article explores the rise of reactive programming in Java, explains concurrency versus parallelism, demystifies backpressure, and compares the Reactor and RxJava frameworks, offering practical insights for modern high‑concurrency server development.
ConcurrencyJavaRxJava
0 likes · 12 min read

This article explains what reactive programming is, outlines the Reactive Manifesto's four core principles, describes the Reactive Streams standard and its key interfaces, showcases Java code examples with Reactor, and provides practical guidance for adopting reactive architectures in backend systems.
JavaReactive ProgrammingReactive Streams
0 likes · 13 min read

This article explains Spark Streaming's backpressure mechanism, detailing how batch intervals can cause data accumulation, the role of Receivers versus DirectKafkaInputDStream, configuration to enable backpressure, and the internal workings of RateController, ReceiverRateController, ReceiverSupervisor, BlockGenerator, and rate calculations for Kafka streams.
KafkaRateControllerReceiver
0 likes · 12 min read

This article provides a comprehensive overview of Apache Flink, explaining how it unifies stream and batch processing on a single runtime, detailing its key features, APIs, libraries, architectural components, fault‑tolerance mechanisms, scheduling, iterative processing, and back‑pressure monitoring.
Apache Flinkbackpressurebatch processing
0 likes · 20 min read

Backpressure, the resistance to data flow in overloaded systems, is crucial for reliable asynchronous programming; this article explains its concepts, illustrates pitfalls in Python asyncio and other languages, and presents strategies such as buffering, draining, semaphores, and protocol-level flow control to manage overload.
ConcurrencyFlow ControlPython
0 likes · 16 min read

This article compares Flink and Spark Structured Streaming, detailing their differences in join capabilities, state management, fault‑tolerance mechanisms, exactly‑once semantics, back‑pressure handling, and table registration, while providing code examples and practical insights for real‑time big‑data processing.
FlinkSpark Structured StreamingState Management
0 likes · 13 min read

This article explains RxJava2's backpressure mechanisms, compares the five Flowable strategies (MISSING, ERROR, BUFFER, DROP, LATEST), demonstrates their behavior with practical experiments, and shows how to use Subscription and FlowableEmitter to build a demand‑driven, memory‑safe data pipeline.
ConcurrencyFlowableReactive Programming
0 likes · 20 min read

This article provides a comprehensive overview of RxJava2 for Android, covering its observer types, backpressure strategies, thread‑scheduling transformers, the compose() operator, differences between compose and flatMap, and the distinction between hot and cold observables with practical code examples.
AndroidObservablesReactive Programming
0 likes · 6 min read

The article explains how Spark Streaming backpressure, introduced in version 1.5, automatically adjusts data ingestion rates based on processing delays, replaces manual rate limits, and details its architecture, configuration parameters, and usage for preventing data backlog and executor OOM.
Rate ControlSparkbackpressure
0 likes · 6 min read

This article compares Spark Streaming and Flink across runtime models, component roles, programming APIs, task scheduling, time semantics, dynamic Kafka partition detection, fault‑tolerance mechanisms, exactly‑once guarantees, and back‑pressure handling, providing code examples and practical insights for real‑time data processing.
Dynamic Partition DetectionFlinkKafka Integration
0 likes · 23 min read

This article explains the fundamentals of reactive programming in Spring 5, covering concepts like reactive streams, backpressure, Reactor's Mono and Flux types, and provides practical code examples for controllers and data layers to illustrate the benefits over traditional blocking approaches.
FluxReactive ProgrammingReactor
0 likes · 7 min read

This article explains the Reactive Streams standard, its back‑pressure concept—including blocking and non‑blocking approaches—and details the core API types (Publisher, Subscriber, Subscription) and their interaction flow for asynchronous data processing.
JavaPublisherReactive Streams
0 likes · 4 min read

The article provides a comprehensive overview of Twitter's Heron stream processing system, comparing its architecture, design principles, back‑pressure mechanisms, resource utilization, and performance test results with Storm/JStorm, and concludes with practical insights for large‑scale deployments.
HeronStormarchitecture
0 likes · 23 min read

The article explains Node.js’s Stream API by detailing the four core stream classes—Readable, Writable, Duplex, and Transform—showing how to implement them, manage back‑pressure, enable objectMode, and apply these concepts in real‑world tools like Gulp, Browserify, and a Git‑changelog generator.
DuplexNode.jsObjectMode
0 likes · 6 min read

The article explains Node.js stream internals, showing how readable, writable, and transform streams manage data production and consumption, the roles of _read, read, push, and doRead, the two operating modes, and how pipe implements back‑pressure via high‑water marks to ensure memory‑safe, efficient processing.
Node.jsPipeStream
0 likes · 22 min read

This article investigates the conditions under which Node.js’s drain event is emitted, explores its relationship with socket.write’s return value and highWaterMark, demonstrates experiments with TCP and HTTP streams, and shows how to implement proper back‑pressure handling using pause/resume or pipe.
Node.jsbackend developmentbackpressure
0 likes · 13 min read

This article explains Netty's autoread switch, isWritable back‑pressure mechanism, and serialization strategies, showing how to control read/write rates, avoid thread‑pool overload, and reduce memory copies when handling TCP byte streams in high‑performance Java network applications.
ConcurrencyNIONetworking
0 likes · 14 min read
