This article explains Java's I/O mechanisms—blocking BIO, non‑blocking NIO, and asynchronous AIO—detailing their definitions, key differences, appropriate use‑cases, and provides practical code examples for reading and writing files with each approach in Java applications.
The article examines Hadoop’s RPC framework—detailing its client‑server workflow, core classes (RPC, Client, Server), dynamic proxy handling, NIO‑based server threading, configurable concurrency controls such as FairCallQueue, and a practical HDFS mkdir command example, illustrating high‑performance distributed communication.
This article explains how traditional per‑connection thread handling (blocking I/O) wastes resources, then demonstrates Java NIO multiplexing and AIO callbacks with complete code examples, showing how they reduce thread usage and eliminate blocking while processing many simultaneous socket connections.
This article explains Netty’s high‑performance asynchronous NIO architecture, its three‑layer design, I/O and threading models, serialization options, reliability, security features, traffic shaping, and graceful shutdown, showing why it’s the preferred framework for backend and distributed systems.
This article explains the concept of zero‑copy, its I/O fundamentals, and how Java, Netty, RocketMQ and Kafka use mmap, sendfile and other techniques to eliminate data copies and boost backend throughput and latency.
This article provides a comprehensive tutorial on installing Apache Tomcat, setting up the required JDK, configuring environment variables, adjusting server ports, and applying performance optimizations such as disabling AJP, switching to NIO, enabling external thread pools, and tuning JVM options for production use.
Netty is a high‑performance, asynchronous, event‑driven NIO framework that supports TCP, UDP and file transfer, offering robust, customizable, and scalable networking solutions widely adopted across internet, big‑data, gaming and telecom industries, with detailed analysis of its architecture, I/O model, threading, serialization, reliability, traffic shaping, graceful shutdown, and security features.
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.
This article explains how TCP three‑way handshake, half‑ and full‑connection queues, and the backlog setting can cause intermittent client‑server connection failures, and shows how to detect and resolve queue overflows using netstat, ss, and proper backlog configuration.
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 provides a comprehensive guide to Java I/O, explaining the distinction between byte and character streams, the role of abstract and concrete stream classes, how the Decorator pattern extends functionality, the enhancements introduced in NIO.2, and the use of asynchronous I/O with Futures and Callbacks.
This article explains Tomcat's NIO architecture, covering the I/O multiplexing model, Tomcat's support for various I/O models, NioEndpoint component relationships, step‑by‑step source‑code analysis, performance considerations, and practical configuration tips for optimizing high‑concurrency Java servers.
This article introduces Java NIO fundamentals, explaining the key concepts of Channel, Buffer, and Selector, comparing them with traditional I/O streams, and providing code examples for file reading, writing with FileChannel, and illustrating how selectors enable single‑threaded multiplexed I/O handling.
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 introduces Java I/O fundamentals, explains the four I/O interface groups, details the File class methods, provides a complete code demo with execution results, and highlights important points such as mkdirs behavior and cross‑platform path separators.
This article explains the principles of TCP long connections, compares NIO and BIO models, and describes how Android applications can implement and share persistent connections using AIDL, process sharing, and a dedicated SDK to support push, IM, and other real‑time services.
This article delves into Kafka’s network layer implementation, explaining the Selector class’s role in registering socket channels, handling connection events, and orchestrating reads and writes via KafkaChannel and TransportLayer, while illustrating packet structures and providing code snippets for key functions like register, connect, poll, and send.
This article explains Java NIO fundamentals—including synchronous vs asynchronous, blocking vs non‑blocking I/O—covers core components such as Channel, Buffer, and Selector, and provides complete example code for file operations and a single‑threaded server/client, comparing NIO with traditional I/O.
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.
The article explains how NIO replaces the thread‑intensive blocking I/O model with a non‑blocking, event‑driven architecture that lets a single thread handle many connections, covering BIO vs NIO differences, selector mechanics, Reactor/Proactor patterns, buffer strategies, practical use cases, and framework recommendations.
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 internal design of Kafka's SocketServer, detailing its NIO‑based thread model with Acceptor, Processor, and Handler threads, the startup sequence, how connections are accepted and processed, and the role of RequestChannel in routing requests and responses between processors and handlers.
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.
This guide explains Tomcat's three connector modes—BIO, NIO, and APR—shows how to install APR and native libraries, configure the server.xml protocol, and apply JVM and connector optimizations to dramatically improve concurrency and throughput.
