Tagged articles
IO
78 articles · Page 1 of 1

ZhiKe AIJun 26, 2026 · Backend Development
An interviewer's question about the difference between epoll and select reveals a tangled web of OS‑level IO mechanisms; this article unpacks user‑space vs kernel‑space, DMA, zero‑copy, buffering, and maps the five Java IO models (BIO, NIO, AIO, etc.) to their underlying system calls.
EpollIOJava
0 likes · 17 min read

This article explains the Scanner class in java.util, outlines a four‑step usage pattern, details its API for reading and validation, addresses the common nextInt/nextLine line‑skip issue with two reliable solutions, and provides best‑practice guidelines and example code to avoid resource leaks and input errors.
Best PracticesConsole InputException Handling
0 likes · 10 min read

This comprehensive guide walks you through the Linux IO stack, explains key metrics from iostat and iotop, demonstrates advanced tracing with blktrace and bpftrace, shows how to benchmark with fio, and provides practical tuning steps to resolve high‑IO latency and system hangs.
IOLinuxmonitoring
0 likes · 48 min read

This article compares Java's three I/O communication models—BIO, NIO, and AIO—detailing their characteristics, performance trade‑offs, programming complexities, and suitable scenarios, then examines the limitations of native AIO and how the smart‑socket library enhances it with optimized threading, memory management, stability improvements, and a simplified API.
AIOBIOIO
0 likes · 14 min read

This article compiles essential Spring and Java utility methods—including assertion checks, object and collection handling, file I/O, resource management, and reflection/AOP tools—providing concise code examples and usage guidelines to help developers avoid redundant code and write cleaner, more reliable applications.
IOJavaReflection
0 likes · 13 min read

Python’s async features, introduced in 3.5, excel at network I/O but face limitations from the GIL, lack of async file I/O, and fragmented library support, while upcoming 3.14 enhancements like free threads and sub‑interpreters promise broader concurrency, yet raise new integration challenges.
ConcurrencyGILIO
0 likes · 17 min read

This article presents a coding challenge that asks Java developers to perform common I/O operations—reading files, streams, URLs, sockets, and more—in a single line of code, and demonstrates how the jd.commons library provides concise fluent APIs to achieve these tasks while reducing boilerplate.
Fluent APIIOJava
0 likes · 9 min read

This article explains the principles behind zero‑copy, DMA, and RDMA, compares traditional I/O copying with modern zero‑copy techniques, and shows practical implementations in Linux and Java that dramatically reduce CPU overhead and boost network and file‑transfer throughput.
DMAIOLinux
0 likes · 42 min read


Java OneMar 9, 2025 · Backend Development
This article explains the fundamentals of I/O in Unix and Java, covering the distinction between user and kernel space, the five Unix I/O models, the evolution from select/poll to epoll/kqueue, and how modern network frameworks like Reactor and Proactor leverage these mechanisms for high‑performance networking.
EpollIOJava
0 likes · 16 min read

This article provides a comprehensive guide to Java I/O streams, covering the distinction between node (low‑level) and processing (high‑level) streams, byte versus character streams, their superclasses, common implementations, buffering techniques, object serialization, and practical code examples for reading and writing data.
ByteStreamCharacterStreamIO
0 likes · 16 min read

This article explains the fundamentals of input/output (IO) in operating systems, covering the basic IO concept, the role of the OS, the two‑phase IO call process, and detailed descriptions of blocking, non‑blocking, multiplexed (select, poll, epoll), signal‑driven and asynchronous IO models with example code.
EpollIOMultiplexing
0 likes · 13 min read

This article explains the fundamentals of input/output (IO) in operating systems, covering the basic IO concept, the role of the OS, the two-stage IO process, and various IO models such as blocking, non‑blocking, select/poll/epoll, signal‑driven and asynchronous approaches.
EpollIOOperating Systems
0 likes · 13 min read

This article walks through the most commonly used Google Guava packages, demonstrating how to handle strings, collections, primitives, I/O, and various utility classes with concise code snippets and practical tips to boost Java development productivity.
ConcurrencyGoogle GuavaGuava utilities
0 likes · 18 min read

This article explains the concept of zero‑copy, compares traditional I/O copying with mmap, sendfile, DMA scatter/gather and splice techniques, and shows how Java NIO leverages mmap and sendfile to achieve high‑performance data transfer while minimizing CPU involvement.
IOJava NIOZero-Copy
0 likes · 15 min read

This article provides a concise guide to SpringBoot’s built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—explaining their purpose, key methods, and offering ready‑to‑use code examples to boost development efficiency.
IOJavaReflection
0 likes · 14 min read

This article explains the fundamentals of disks, differentiates mechanical HDDs and SSDs, describes disk I/O concepts, outlines key performance metrics such as IOPS, throughput, utilization and saturation, and introduces Linux tools like iostat, iotop and sar for monitoring and analyzing storage performance.
IOStoragedisk
0 likes · 25 min read

Zero‑copy is an optimization technique that eliminates unnecessary memory copies between kernel and user space by leveraging DMA, memory‑mapping and specialized system calls, thereby reducing CPU load, latency and improving throughput for high‑performance networking, storage and multimedia workloads.
DMAIOLinux
0 likes · 18 min read

This article explains why threads are essential for performance, how to create and configure Java thread pools using the Executors utility, distinguishes CPU, IO, and scheduled pool types, and demonstrates monitoring techniques for latency and deadlock detection with practical code examples.
CPUConcurrencyExecutorService
0 likes · 25 min read

This article provides a comprehensive walkthrough of Go's core file‑handling libraries—including the io, os, and embed packages—detailing their interfaces, utility functions, and practical code examples so beginners can confidently read, write, and serve files in Go applications.
GoIOOS Package
0 likes · 19 min read

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.
EpollIOMultiplexing
0 likes · 12 min read

This article walks through using Python's pdfplumber and built‑in io modules to read PDF invoices directly into memory, avoid intermediate files, and process the data programmatically, providing code snippets and explanations that helped a community member solve their automation challenge.
IOpdfplumber
0 likes · 4 min read

This article provides a comprehensive overview of Spring Framework utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AopUtils—explaining their purpose, key methods, and usage examples with code snippets for backend developers.
BackendIOJava
0 likes · 14 min read

This article introduces the most commonly used Spring Boot utility classes—including assertions, object and collection helpers, file/IO utilities, reflection, and AOP support—providing code examples and usage guidelines to help Java backend developers write cleaner, more efficient code.
Backend DevelopmentIOJava
0 likes · 19 min read

This article introduces the basic concepts of I/O and explains three Unix network programming models—blocking I/O, non‑blocking I/O, and I/O multiplexing—detailing their workflows, advantages, disadvantages, and practical analogies for better comprehension.
IOIO Multiplexingblocking IO
0 likes · 10 min read

This article introduces Java I/O streams, explains how to efficiently read large files using buffered streams and NIO, details the core components of Java NIO (Channel, Buffer, Selector), and covers object serialization, the role of serialVersionUID, and alternative serialization frameworks.
IONIOSerialization
0 likes · 12 min read

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.
BackendIOJava
0 likes · 5 min read

This article introduces Java's three generations of IO frameworks, explains the differences between blocking BIO, NIO, and NIO2, details byte and character streams, and provides complete example programs for writing to and reading from text files using try‑with‑resources and stream conversions.
BIOFileIO
0 likes · 14 min read

This article deeply explores JDK NIO's file reading and writing mechanisms, revealing how Buffered and Direct IO interact with Linux's page cache, the kernel's radix tree, prefetch algorithms, and dirty page management, while providing practical code examples and performance insights for developers.
IOJavaLinux kernel
0 likes · 86 min read

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.
EpollIOLinux
0 likes · 14 min read

This article walks through Dubbo’s RPC communication using a packet‑as‑narrator metaphor, detailing the thread models of Netty 3 and Netty 4, OS socket handling, and practical troubleshooting steps for latency and timeout issues in a clear, engaging style.
DubboIONetty
0 likes · 11 min read

This article provides a comprehensive guide to Spring's most useful utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, ReflectionUtils, and AopUtils—detailing their purpose, key methods, and practical code examples for backend developers.
IOJavaReflection
0 likes · 13 min read

The article explains Java's I/O ecosystem, covering synchronous blocking BIO, synchronous non‑blocking NIO, and asynchronous non‑blocking AIO, their classifications, practical code examples, and when to choose byte streams versus character streams.
AIOBIOBufferedStream
0 likes · 12 min read

This article traces the historical origins of coroutines from early COBOL compiler challenges, explains their cooperative execution model, compares them with thread scheduling, and reviews how modern languages like Python, C++ and Go implement coroutine support to improve IO‑bound performance.
C++GoIO
0 likes · 16 min read

This article analyzes why Alipay’s cold start on our device is slower than on competing phones and presents a series of optimizations—including CPU boosting, Dex2oat strategy adjustments, GC frequency reduction, and I/O improvements—that collectively close the performance gap.
AndroidCPUCold Start
0 likes · 11 min read

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.
IOMultiplexingNonBlocking
0 likes · 3 min read

The article explains Redis 6.0's new features—especially the multithreaded network I/O model—why earlier versions were single‑threaded, how the IO threads cooperate with the main thread, configuration steps, thread‑count recommendations, and the model's limitations and performance implications.
ConfigurationIOMultithreading
0 likes · 9 min read

The article explores why Vim becomes painfully slow when opening or saving a 10 GB file, detailing the editor's process initialization, its memfile‑based virtual storage, the full‑file read performed by readfile, and the multi‑step write sequence triggered by the :w command.
IOfile handlingsource code
0 likes · 17 min read

This article explains Java NIO buffers, covering how to create them, their four core properties (mark, position, limit, capacity), essential methods like allocate, allocateDirect, flip, rewind, clear, and demonstrates usage with comprehensive code examples and diagrams.
BufferByteBufferIO
0 likes · 11 min read

This article introduces Go's standard library io package, explains the io.Reader and io.Writer interfaces, demonstrates how to use them with built‑in types, shows how to implement custom Readers and Writers, and covers related utilities such as io.Copy, pipes, buffered I/O, and file operations.
IOReaderStream
0 likes · 18 min read

This article explains the core differences between Java NIO and traditional IO, introduces channels and buffers, details NIO’s underlying mechanisms, provides a complete code example, and compares NIO’s workflow with Netty’s model, highlighting performance and architectural distinctions.
Backend DevelopmentBuffersChannels
0 likes · 13 min read

This article explains the core differences between Java NIO and traditional IO, introduces the concepts of channels and buffers, describes buffer state management, provides a complete NIO selector code example, and compares the NIO workflow with Netty's model.
BackendBuffersChannels
0 likes · 10 min read

This article traces the real system‑call flow of Java’s I/O models—BIO, NIO, Netty and AIO—on CentOS 7.5, compares their performance, lists advantages and disadvantages, and shows how each model interacts with the Linux kernel via strace.
AIOIOJava
0 likes · 23 min read

This article explains the various classifications of Linux I/O—including buffered, direct, synchronous, and asynchronous types—describes the kernel’s block layer and I/O scheduler algorithms, and provides practical guidance for measuring disk performance using the FIO tool with example commands and scripts.
IOSchedulingdisk performance
0 likes · 11 min read

This article dives deep into Go's io package, detailing the core Reader and Writer interfaces, their variants like ReaderAt, WriterAt, ReaderFrom, WriterTo, and practical functions such as Copy, CopyBuffer, and Pipe, complete with clear code examples and performance insights.
COPYIOPipe
0 likes · 16 min read

This comprehensive guide explains the differences between object‑oriented and procedural programming, outlines SOLID design principles, compares abstract classes with interfaces, clarifies variable scopes and static versus instance members, and covers Java I/O models including BIO, NIO, AIO, and common Files utilities.
IOJavaOOP
0 likes · 16 min read

This article compares object‑oriented and procedural programming, outlines the five SOLID principles, contrasts abstract classes with interfaces, and covers Java fundamentals such as constructors, variable scopes, static members, method return values, value passing, common packages, IO stream models, BIO/NIO/AIO differences, and essential Files API methods.
IOJavaOOP
0 likes · 18 min read

This article explains Java NIO fundamentals—including Channels, Buffers, and Selectors—compares them with traditional IO, and provides multiple runnable code examples such as FileChannel, SocketChannel, Selector loops, memory‑mapped files, scatter/gather, transferTo/From, Pipe and DatagramChannel to illustrate non‑blocking and high‑performance I/O.
BufferIOJava
0 likes · 31 min read

Android inherits Linux file descriptors, which are indexed by non‑negative integers and limited per process, and this article explains their kernel structures, common leak sources such as HandlerThread eventfd, unclosed streams, and SQLite cursor windows, plus practical commands and monitoring techniques to detect and fix FD leaks.
AndroidFD LeakFileDescriptor
0 likes · 20 min read

This article outlines a systematic approach to high‑performance, high‑concurrency backend development by examining CPU speed, cache and multithreading, memory hierarchy and paging, I/O optimization techniques, and the architectural patterns that tie these components together.
BackendConcurrencyIO
0 likes · 13 min read

This article explains the fundamentals of Java IO, covering the definition of streams, their characteristics, classification by direction, data unit and function, the role of node and processing streams, buffering for performance, serialization, and includes extensive code examples and efficiency comparisons.
Buffered StreamsFile I/OIO
0 likes · 23 min read

This article demonstrates how to simplify Java exception handling by using behavior parameterization, lambda expressions, and functional interfaces together with try‑with‑resources, turning noisy try‑catch blocks into clean, reusable code for both checked and unchecked exceptions.
Functional InterfaceIOJava
0 likes · 5 min read


ITPUBOct 13, 2020 · Fundamentals
This article provides a comprehensive, step‑by‑step explanation of Linux fundamentals—including the kernel architecture, process and thread creation, memory management, filesystem structures, I/O handling, and built‑in security mechanisms—illustrated with code snippets and diagrams.
FilesystemIOmemory-management
0 likes · 104 min read

This article compiles typical backend interview questions covering spin locks versus regular locks, various I/O models, cache‑related pitfalls, Redis eviction strategies, MySQL locking and logging mechanisms, and the principles of skip lists and other fundamental data structures.
IOInterview
0 likes · 19 min read

This guide demonstrates a complete Java socket implementation that lets a client read an image file, stream its bytes over a TCP connection to a server, and have the server reconstruct and save the picture to disk.
IOJavaSocket
0 likes · 4 min read

This article provides a comprehensive overview of Java IO, explaining the traditional blocking BIO model, the modern non‑blocking NIO architecture, the role of streams, buffers, channels, zero‑copy techniques, and selectors, and includes practical code examples for file copying and simple client‑server communication.
BuffersChannelsIO
0 likes · 35 min read

A real‑world incident showed that a 0% CPU idle rate can mask severe disk IO wait, leading to thread exhaustion in a SpringBoot order service, and the article explains how IO, DMA, Java thread states, and various Linux network IO models interact while offering practical mitigation tactics.
CPUIOJava
0 likes · 14 min read

This article explores the fundamentals of high‑performance I/O design in Java, comparing BIO and NIO throughput, analyzing thread‑based and event‑driven architectures, and detailing the Reactor pattern with code examples and performance considerations for scalable web services.
BIOIOJava
0 likes · 18 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

This article explains the fundamental differences between Java NIO and traditional IO, introduces channels and buffers, describes NIO's internal mechanisms, provides a complete code example, and compares NIO's workflow with Netty's model for high‑performance backend development.
BackendBuffersChannels
0 likes · 11 min read

This article explains the core differences between Java NIO and traditional IO, introduces the concepts of channels and buffers, details buffer state management, and provides sample NIO code along with a comparison to Netty's processing model.
BuffersChannelsIO
0 likes · 9 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 Java's Input/Output mechanisms, detailing the differences between Blocking IO (BIO), Non‑blocking IO (NIO), and Asynchronous IO (AIO), their synchronization models, suitable scenarios, and provides practical code samples for reading and writing files using each approach.
AIOBIOFile I/O
0 likes · 10 min read

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.
AIOBIOFile I/O
0 likes · 10 min read

This article examines Kotlin Multiplatform's evolution, detailing native compilation, cinterop bindings, platform libraries, bidirectional Swift/Objective‑C interop, and practical cross‑platform implementations for logging, file I/O, and SQLite, while outlining future directions and tooling recommendations.
IOKotlinLogging
0 likes · 21 min read

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.
AIOConcurrencyIO
0 likes · 35 min read

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.
IOJavaSynchronization
0 likes · 8 min read

The article presents a systematic, top‑down methodology for machine‑learning performance optimization—covering principles, benchmark‑driven loops, foundational hardware and software checks, profiling tools, throughput and latency metrics, and practical techniques for IO, compute, mixed‑precision, and distributed training to maximize resource utilization.
ComputeIOMachine Learning
0 likes · 22 min read

This article breaks down eight core Java interview questions, offering deep analysis of platform fundamentals, exception handling, reflection, I/O, concurrency, and object‑oriented design to help candidates demonstrate solid understanding beyond superficial answers.
ConcurrencyCore ConceptsException Handling
0 likes · 12 min read

This article explains Java's I/O system, detailing how streams and decorator patterns enable flexible file reading and writing, and provides clear code examples illustrating BufferedReader, FileReader, InputStream, and OutputStream usage.
BufferedReaderDecoratorFileReader
0 likes · 7 min read

This guide explains the three main performance bottlenecks—CPU, network I/O, and disk I/O—on Linux servers, offers concrete optimization techniques for each, and introduces essential diagnostic tools such as top, free, vmstat, strace, tcpdump, and gprof to pinpoint and resolve issues.
CPUIOLinux
0 likes · 7 min read

This comprehensive guide introduces Java fundamentals, covering object‑oriented concepts, the collections framework, various I/O streams, socket communication, relational database basics with SQL examples, and an overview of JSP, its objects, directives, and web application lifecycle.
IOJSPJava
0 likes · 14 min read

The article analyzes why dropping large InnoDB tables in MySQL can drastically degrade overall database performance due to buffer‑pool mutex and file‑system I/O bottlenecks, and presents both operational work‑arounds and source‑code modifications to alleviate the issue.
Buffer PoolDROP TABLEIO
0 likes · 10 min read

This article explains the concept of streams, classifies Java IO streams into character/byte and input/output types, details the main InputStream and OutputStream class hierarchies, and describes related classes such as Reader, Writer, File, and RandomAccessFile for effective data handling.
IOInputStreamOutputStream
0 likes · 10 min read

This article explains the key SSD benchmark indicators—4K random I/O, sustained throughput, performance consistency, durability, and write amplification—while describing why they matter for evaluating storage solutions and guiding proper SSD selection for production workloads.
IOSSDStorage
0 likes · 5 min read

This guide explains why server IO utilization spikes above 60% during early‑morning hours, covering hardware self‑test, RAID battery failures, cache policy misconfigurations, and step‑by‑step commands for MegaRAID and HP servers, plus BIOS adjustments and best‑practice recommendations to prevent performance degradation.
IOMegaCliMySQL
0 likes · 16 min read

This article explains InnoDB's file I/O interfaces, asynchronous and synchronous read/write mechanisms, background IO threads, AIO request handling, concurrency controls, prefetch strategies, log write padding, and the evolution of buffer pool initialization, chain management, and page eviction in MySQL 5.7.
Buffer PoolIOInnoDB
0 likes · 19 min read

This article explains the architecture and code flow of InnoDB's IO subsystem, covering read/write threads, asynchronous AIO handling, concurrency control, file prefetch strategies, and log write padding, with detailed examples of the underlying C++ structures and functions.
Database EngineIOInnoDB
0 likes · 13 min read

The article explains how web front‑end optimization, including static site generation, relies on improving browser‑server performance by addressing CPU, storage, and especially network bottlenecks, and argues that front‑end engineers should view themselves as browser‑application experts rather than just HTML/CSS/JS coders.
CPUIOnetwork
0 likes · 16 min read
