Tagged articles
Reactor
39 articles · Page 1 of 1
This article explains how TraceId propagates across services, threads, and message queues in Spring Cloud, covering W3C/B3 formats, Micrometer Tracing architecture, cross-thread context propagation via ThreadLocal and Reactor Context, MQ header injection, sampling strategies, and common pitfalls with solutions.
Distributed TracingMicrometerReactor
0 likes · 36 min read

Microsoft's experimental Reactor framework lets developers describe WinUI interfaces in C#, while Teams migrates from Electron to WebView2 for performance gains; however, Reactor doesn't fix WinUI's ecosystem gaps, and AI coding tools reduce learning curves but shift complexity to per-app native concerns like UI threading and object lifecycles.
AI programmingElectronMicrosoft
0 likes · 3 min read

The article explains that achieving stable performance for Spring Cloud Gateway at a million‑request scale requires a reactive non‑blocking model, comprehensive rate‑limiting and circuit‑breaker mechanisms, and optimized connection management and routing to handle high concurrency efficiently.
Circuit BreakerNettyReactor
0 likes · 5 min read

The article examines a real‑world incident where ThreadLocal leakage caused user data mix‑ups, then walks through the evolution of context propagation—from implicit ThreadLocal to TTL patches, Reactor Context, ScopedValue, and Go's explicit context—highlighting trade‑offs and best practices for high‑throughput systems.
ConcurrencyContextPropagationGoContext
0 likes · 15 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

This article details the design and implementation of a visual canvas‑based marketing configuration system that replaces Apollo, introduces a custom Reactor‑powered workflow engine, outlines component ecosystems, solves concurrency challenges, and demonstrates significant efficiency, scalability, and reliability gains after deployment.
CanvasConcurrencyReactor
0 likes · 15 min read

This article introduces the five most common Reactor error‑handling operators—onErrorReturn, onErrorResume, doOnError, retry, and blockOptional—explains their distinct behaviors, appropriate scenarios, and common pitfalls, and provides concise code examples for each within Spring WebFlux.
JavaReactive ProgrammingReactor
0 likes · 6 min read

This article explains how backpressure works in Spring WebFlux, outlines the built‑in Reactor strategies, provides practical code examples for handling slow consumers, and offers guidance on choosing and monitoring the right approach to keep reactive applications resilient under load.
JavaReactorServer-Sent Events
0 likes · 14 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

This article explains how Maven’s reactor determines build order in a parent‑child multi‑module project and demonstrates how to use command‑line options such as -pl, -rf, -am, and -amd to build only required modules or their dependents, greatly speeding up the build process.
BackendMulti-ModuleReactor
0 likes · 8 min read

This article explains how PHP’s socket extension can be used for network programming, walks through traditional multi‑process/thread blocking models, introduces IO multiplexing with the Reactor pattern, and shows how the Swoole extension enables efficient asynchronous and coroutine‑based server development.
Async ProgrammingConcurrent IOPHP
0 likes · 20 min read

This article explains the fundamentals of Reactor and Proactor event‑handling patterns, discusses Linux’s limited AIO support, and presents seven practical server concurrency models—from single‑threaded accept to multi‑process thread‑pool designs—detailing their workflows, advantages, drawbacks, and suitable use cases.
ProactorReactorbackend architecture
0 likes · 21 min read

This article introduces Spring WebFlux, a reactive web framework introduced in Spring 5, explains the concept of reactive programming, compares it with Spring MVC, describes its concurrency model, and provides practical code examples for building a WebFlux application with Spring Boot.
JavaReactive ProgrammingReactor
0 likes · 8 min read

This article introduces Spring WebFlux as a reactive, non‑blocking web framework for Java, explains the concepts of reactive programming, compares it with Spring MVC, and provides practical code examples—including Mono/Flux usage, routing, and handlers—to help developers build and run a WebFlux application with Spring Boot.
JavaReactive ProgrammingReactor
0 likes · 8 min read

The article shows how a unified abstraction called statefulMap, together with a resource‑aware mapWithResource primitive, lets developers implement a wide range of complex reactive‑stream operators—such as buffering, indexing, deduplication, and safe DB access—in a concise, composable, thread‑safe manner, dramatically reducing boilerplate code.
AkkaJavaReactive Streams
0 likes · 15 min read


HomeTechOct 19, 2022 · Backend Development
This article explores the use of Reactor in Spring Cloud Gateway, highlighting its role in enabling reactive programming for efficient API gateway implementations through non-blocking, asynchronous operations and advanced data flow management.
API GatewayReactive ProgrammingReactor
0 likes · 12 min read

This article introduces Spring WebFlux, explains reactive programming concepts, compares it with Spring MVC, and provides practical code examples demonstrating how to build a reactive web application using Spring Boot, Reactor's Mono and Flux, and functional routing.
FluxReactive ProgrammingReactor
0 likes · 10 min read

To overcome Go’s per‑connection goroutine memory and GC limits at massive scale, the article designs a three‑layer Reactor‑based network library that uses epoll/kqueue, lock‑protected file descriptors, zero‑copy buffers, and load‑balanced sub‑reactors, enabling stable operation with up to a million concurrent connections.
GoReactorasynchronous IO
0 likes · 19 min read

This article provides a comprehensive, code‑driven walkthrough of Netty's internal networking architecture, covering NioEventLoopGroup, selectors, channels, pipelines, bootstrap configuration, binding mechanics, and how new connections and user requests are processed in a Java server environment.
EventLoopJavaNetty
0 likes · 26 min read

This article introduces Netty, explains Java's BIO/NIO/AIO models, compares reactor threading architectures, details Netty's internal thread and handler pipeline design, and provides a complete example of building a high‑performance HTTP server with Netty.
BackendJavaNIO
0 likes · 17 min read

This article explains the limitations of traditional blocking I/O, introduces Java NIO with selectors, compares the two models using a kindergarten analogy, critiques raw JDK NIO, and demonstrates how Netty simplifies and optimizes network development with concise server and client code examples while promoting a comprehensive Netty learning book.
Java NIOReactorServer-Client
0 likes · 17 min read

This article explains the complete flow of how Netty's Sub‑Reactor processes OP_READ events, from selector polling to channel pipelines, and details the adaptive mechanisms of AdaptiveRecvByteBufAllocator and PooledByteBufAllocator that dynamically resize DirectByteBuffers for optimal network data reception.
AdaptiveRecvByteBufAllocatorByteBufferNetty
0 likes · 36 min read

This article dissects Netty’s core connection‑acceptance mechanism, explains how the OP_ACCEPT event is processed, reveals a subtle bug that limits read loops to a single connection, and shows the fix introduced in version 4.1.69.final, offering developers a complete understanding of Netty’s reactor architecture.
Java NIONettyOP_ACCEPT
0 likes · 40 min read

This article explains how Netty constructs its core reactor thread pool using NioEventLoopGroup, detailing the creation of boss and worker groups, the underlying selector optimization, task queue setup, and the round‑robin binding strategy that distributes channels across multiple event loops for high‑performance I/O handling.
IO MultiplexingJava NIONetty
0 likes · 39 min read

This article explains the fundamentals of Reactor's reactive programming model—including Mono and Flux types, map and flatMap operators, asynchronous execution, scheduler choices, and error handling—while providing practical code examples to help developers efficiently use Spring WebFlux.
FluxJavaReactive Programming
0 likes · 26 min read

The article explains how Spring WebFlux, built on the Reactor project, offers a non‑blocking, reactive alternative to traditional Spring Web MVC, detailing its relationship with servlet containers, the advantages of Reactive Streams, and considerations for adopting it in Java backend development.
ReactorWebFluxreactive
0 likes · 8 min read


JavaEdgeJan 1, 2021 · Backend Development
This article breaks down Kafka’s network communication layer, detailing the roles of SocketServer, the Acceptor thread, Processor threads, and related classes such as RequestChannel, KafkaRequestHandlerPool, and key configuration parameters, while illustrating their interactions with diagrams.
BackendJavaKafka
0 likes · 7 min read

This tutorial provides a detailed introduction to Netty, covering its architecture, core concepts such as buffers, channels, selectors, reactor thread models, zero‑copy techniques, and includes practical TCP server/client code examples, helping readers understand and apply Netty for high‑performance Java network programming.
Java NIONettyReactor
0 likes · 42 min read

This article explains Netty as an asynchronous event‑driven network framework, compares synchronous and asynchronous processing, describes event‑driven programming, details the differences among BIO, NIO and AIO I/O models, and outlines Netty's core components and architecture.
JavaNettyProactor
0 likes · 10 min read

This article explains the evolution of Java I/O—from blocking BIO to non‑blocking NIO and asynchronous AIO—covers the Reactor pattern and its single‑thread, multi‑thread, and master‑slave models, and details Netty’s thread groups, channel pipeline, and async non‑blocking communication.
BackendI/OJava
0 likes · 13 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 walks through the progression of Java server‑side I/O—from classic blocking BIO, through multithreaded and thread‑pool BIO variants, to non‑blocking NIO and Reactor‑based scalable designs—explaining core concepts, code examples, and performance trade‑offs.
IOJavaMultithreading
0 likes · 15 min read

The article explains IO models—from blocking IO’s limitations to non‑blocking and multiplexing techniques like select, poll, and epoll—then shows how libevent encapsulates these mechanisms to provide a Reactor‑style event‑driven framework, illustrated with a simple echo server implementation.
IOReactorlibevent
0 likes · 7 min read

This article explains what Netty is, reviews traditional HTTP server processing, introduces Java NIO and its non‑blocking event model, compares BIO and NIO, describes Netty's reactor thread architectures, discusses TCP sticky/half‑packet problems and their solutions, and details Netty's zero‑copy techniques for high‑performance networking.
Reactor
0 likes · 12 min read

This article explains the main components of Cloud Foundry, the role of the NATS messaging system, and compares the Reactor and Proactor patterns for synchronous and asynchronous I/O, providing detailed step‑by‑step workflows for read and write operations.
Cloud FoundryIO modelsNATS
0 likes · 7 min read

This article explains Kafka's NIO‑based Reactor network communication model, detailing its 1‑Acceptor + N‑Processor + M‑Handler thread architecture, the roles of SocketServer, Acceptor, Processor, RequestChannel, KafkaRequestHandler and KafkaApis, and includes source code excerpts for deeper insight.
BackendNIOReactor
0 likes · 14 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 fundamental concepts of I/O models—including synchronous vs. asynchronous, blocking vs. non‑blocking, the five classic I/O models, and the Reactor and Proactor design patterns—using clear definitions, examples, and Java code snippets to illustrate each approach.
I/OJavaNIO
0 likes · 16 min read


21CTOMar 23, 2016 · Backend Development
This article explains the evolution of concurrent I/O in PHP—from traditional multi‑process and multi‑thread blocking models, through the leader‑follower pattern and I/O multiplexing with epoll, to modern asynchronous programming using the Reactor model, coroutines, and the high‑performance Swoole extension.
ConcurrencyReactorasync IO
0 likes · 17 min read
