The article explains how to perform fuzzy queries in Redis using KEYS, SCAN, and collection‑type scans, enumerates commands that can block the single‑threaded server such as KEYS *, HGETALL, LRANGE, and provides practical mitigation strategies like incremental scans, key sharding, and asynchronous deletion.
This article demystifies the differences between concurrency, asynchrony, blocking and non‑blocking in Kotlin coroutines by providing runnable examples, experiments, and detailed analysis of thread usage, dispatcher behavior, and performance outcomes.
In Redis's single‑threaded model, commands with O(n) or higher complexity—such as KEYS, HGETALL, LRANGE, SMEMBERS, and DEL on large keys—can block the server during traffic spikes, but using incremental scans, key splitting, and async deletion can eliminate the risk and keep services responsive.
This article demystifies the difference between blocking and non‑blocking coroutine work in Kotlin by providing runnable examples, measuring sequential, concurrent, and asynchronous execution, and revealing how thread usage, jobs, and dispatchers affect performance and true parallelism.
This article demystifies the four core concurrency concepts—synchronous, asynchronous, blocking, and non‑blocking—explaining their meanings, relationships, and practical implications with clear examples and a comparison table, helping developers choose the right model for high‑performance, scalable systems.
This article explains why Redis, a single‑threaded in‑memory database, can become blocked, covering five common culprits such as blocking commands, big keys, database flushes, synchronous AOF writes, and the SAVE command, and offers guidance on preventing performance stalls.
This article explains the key concepts of concurrency, parallelism, synchronization, asynchronous execution, blocking, and non‑blocking in Python, providing clear explanations and practical code samples for each concept, including API automation examples for HTTP requests.
This article explains the fundamentals of coroutines, comparing blocking and non‑blocking concepts, process/thread models, and how PHP and Go implement coroutine solutions using event loops, schedulers, and system calls.
Redis’s versatile list commands—such as LPUSH, RPUSH, LPOP, RPOP, BRPOPLPUSH, LPUSHX, and RPUSHX—enable developers to implement efficient FIFO queues, stacks, blocking queues, and advanced patterns like priority or delayed queues, while offering practical tips for monitoring, persistence, and error handling.
This article explains the concept of IO, the role of the operating system, the complete IO workflow, and compares five common IO models—blocking, non‑blocking, select/poll/epoll multiplexing, signal‑driven, and asynchronous—highlighting their mechanisms, advantages, and typical use cases.
The article explains how java.util.UUID.randomUUID relies on OS entropy, can block threads when entropy is low, shows a real‑world thread‑dump example, and provides three remedies: upgrading the JDK, installing haveged, or switching to /dev/urandom.
This article explains why certain Redis commands, persistence mechanisms, and large keys can block the single‑threaded server, detailing the underlying causes, how to detect big keys, and practical ways to mitigate blocking in production environments.
This article explains the two‑stage socket I/O process in Linux, compares blocking, non‑blocking, and I/O multiplexing techniques, details the select, poll, and epoll APIs with their advantages and drawbacks, and provides complete C code examples for a high‑performance TCP server and client.
This article uses a playful dialogue and water‑kettle analogies to explain the differences between synchronous and asynchronous I/O, blocking and non‑blocking operations, and then details Java's three I/O models—BIO, NIO, and AIO—so readers can choose the right approach for their web projects.
This article demystifies the true reasons behind Redis's speed by exploring low‑level I/O mechanisms—from basic BIO to NIO and the Reactor model—explaining socket creation, connection handling, blocking behavior, and how Java’s non‑blocking APIs and system calls work together to achieve high‑throughput networking.
This article explains the concepts of synchronous and asynchronous execution, blocking and non‑blocking operations, user and kernel space, process switching, file descriptors, cache I/O, and compares various Linux I/O models such as blocking, non‑blocking, multiplexing, signal‑driven and asynchronous I/O, including the differences among select, poll and epoll.
This guide walks through three ways to create gRPC Java clients—newBlockingStub, newStub, and newFutureStub—showing their code, usage patterns, and performance characteristics, while also providing a simple server implementation for testing.
This article explains core Linux I/O concepts—including synchronous vs. asynchronous operations, blocking vs. non‑blocking behavior, user and kernel space separation, process switching, file descriptors, cache I/O, and the differences among select, poll, and epoll—providing a comprehensive overview for developers.
This article explains the concepts of synchronous vs. asynchronous execution, blocking vs. non‑blocking operations, user and kernel space, process switching, file descriptors, cache I/O, and compares various Linux I/O models such as select, poll, epoll, signal‑driven and asynchronous I/O.
This article explains the differences between synchronous and asynchronous execution, blocking and non‑blocking operations, user and kernel space, process switching, file descriptors, cache I/O, and compares various I/O models—including blocking, non‑blocking, multiplexing, signal‑driven, and asynchronous—while highlighting the characteristics of select, poll, and epoll.
This article explains the fundamentals of I/O, details how sockets are created, bound, listened to, and accepted, describes the client-side connect process, and clarifies why read, write, accept, and connect operations can block, laying the groundwork for deeper Netty studies.
This article explains the four main I/O models—blocking, non‑blocking, multiplexed (event‑driven) and asynchronous—detailing their mechanisms, kernel interactions, performance implications, and how they differ in handling data readiness for network programming.
This article explains the four main I/O models—synchronous blocking, synchronous non‑blocking, I/O multiplexing (Reactor), and asynchronous I/O (Proactor)—illustrates their characteristics with examples, and encourages readers to share the content after gaining a clearer understanding of these fundamental backend concepts.
This article explains the concepts of blocking and non‑blocking I/O, I/O multiplexing mechanisms such as select, poll and epoll, and the differences between synchronous and asynchronous I/O, then demonstrates Java implementations of BIO, NIO and AIO with sample code.
This article introduces the five Linux I/O models—blocking, non‑blocking, I/O multiplexing, signal‑driven, and asynchronous—explaining core concepts such as blocking vs non‑blocking calls, synchronous vs asynchronous processing, and detailing each model’s execution phases, advantages, and typical use‑cases.
This article breaks down Linux I/O concepts—including memory, network, and disk I/O—explains the two‑phase request flow, details the web request lifecycle, defines blocking, non‑blocking, synchronous and asynchronous operations, and compares five major I/O models with visual diagrams.
This article explains the fundamentals of I/O, detailing the two-phase request process, the flow of a web request, and the differences between blocking, non‑blocking, synchronous, and asynchronous I/O models, including select/poll, signal‑driven, and AIO approaches.
This article explains the HBase data‑write process—including WAL logging, MemStore caching, and HFile flushing—identifies three levels of write‑blocking (HFile, MemStore, RegionServer), and provides configuration tweaks to mitigate blocking in production environments.
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.
This article examines how MySQL's FLUSH TABLE WITH READ LOCK command can cause blocking, detailing two cases where global read locks or table cache flushes stall other operations, explaining the underlying MDL lock mechanisms, table cache handling, and providing code examples and debugging insights.
This article clarifies the concepts of synchronous vs. asynchronous execution and blocking vs. non‑blocking I/O, explains their relationships, provides practical analogies, and details how these models apply to Java I/O operations.
This article explains the five Linux I/O models—blocking, non‑blocking, I/O multiplexing, signal‑driven, and asynchronous—using a fishing metaphor, shows how Java’s BIO/NIO/AIO map to OS mechanisms, and clarifies why most of them are still synchronous despite different implementations.
This article uses a relatable water‑kettle scenario to clarify the differences between synchronous and asynchronous operations, as well as blocking and non‑blocking I/O, and then maps these concepts to Java's three I/O models—BIO, NIO, and AIO—providing clear, practical insight for developers.
This article demystifies socket communication by illustrating the end‑to‑end process of TCP/UDP message exchange, detailing how client and server serialize objects, interact with kernel read/write buffers, handle blocking, acknowledgments, packet headers, and flow control, and why understanding these low‑level mechanisms is crucial for reliable network programming.
This article analyses the performance challenges of high‑concurrency Java applications, explains how misuse of atomic operations and blocking degrade throughput, introduces an asynchronous monitor concept and a concrete AsyncMutex implementation, and presents experimental results showing its scalability advantages over traditional ReentrantLock‑based locking.
This article explains the lifecycle of data in I/O operations, compares blocking, non‑blocking, and asynchronous models, introduces zero‑copy techniques, and details how select, poll, and epoll enable efficient multiplexed I/O handling in server applications.
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.
This article revisits fundamental network I/O concepts, clarifying the differences between blocking, non‑blocking, synchronous, asynchronous, and multiplexed models through clear explanations and illustrative diagrams, helping developers build a solid mental model of how data moves between processes and the kernel.
This article explains the concepts of synchronous and asynchronous communication, blocking and non‑blocking thread behavior, and compares Java I/O models—including BIO, NIO, IO multiplexing, and AIO—highlighting their mechanisms, advantages, and typical use cases.
This article uses a relatable mailbox story to explain Linux socket I/O models—including synchronous blocking, synchronous non‑blocking, I/O multiplexing with select, signal‑driven I/O, and asynchronous I/O—detailing their mechanisms, advantages, drawbacks, and typical code patterns.
The article compares Java's OIO, NIO, and AIO models, explaining how each handles threads, channels, and I/O requests, and clarifies the distinctions between synchronous, asynchronous, blocking, and non‑blocking communication, while discussing thread pooling, selector behavior, and performance implications for massive connections.
This article explains the differences between synchronous and asynchronous I/O, clarifies blocking versus non‑blocking calls, and describes various I/O models—including blocking, non‑blocking, multiplexed, event‑driven, and asynchronous—illustrated with diagrams to help readers understand how the kernel and user processes interact during I/O operations.
This article examines the various scenarios that cause Redis to block—such as expensive commands, fork‑induced overhead, and persistence operations—and provides practical architectural and configuration solutions to keep the event loop responsive even with large data volumes.
The article explores the evolution from single‑core processors to multi‑core systems, explains threading, blocking, and synchronization concepts, and compares high‑performance communication models such as asynchronous I/O, IOCP on Windows and epoll on Linux, highlighting their trade‑offs for backend server scalability.
This article clarifies Unix I/O models by distinguishing synchronous and asynchronous operations, explaining blocking versus non‑blocking behavior, and summarizing the five classic I/O models with practical insights drawn from Richard Stevens' authoritative definitions.
