0 views collected around this technical thread.
Linux kernel I/O mechanisms, from basic file operations and descriptors to advanced models like blocking, non‑blocking, multiplexed, signal‑driven, and asynchronous I/O, are explained in depth, covering their structures, system calls, caching strategies, and performance optimizations such as io_uring.
The article combines practical advice for fresh graduates seeking internships and interview tips, shares a detailed ByteDance three‑round backend interview experience, explains MySQL master‑slave replication stages, binlog formats, and compares blocking, non‑blocking, multiplexed, and asynchronous I/O models.
This article explains the core principles of I/O read/write operations, detailing the data preparation and copying stages, the roles of kernel and user buffers, synchronization models, and performance optimizations such as double buffering, circular buffers, zero‑copy, read‑ahead, and delayed write.
Redis evolved rapidly, with versions up to 5.x handling all core CRUD commands on a single worker thread, while Redis 6 introduced multi‑threaded network I/O to leverage multi‑core CPUs, yet still processes core business commands single‑threadedly for performance and simplicity, as explained with diagrams.
The article explains the purpose, implementation, and usage of early I/O memory mapping (early_ioremap) in the Linux kernel, detailing its initialization, fixmap foundations, code flow, and differences from regular ioremap, with examples and kernel source snippets.
This article provides a comprehensive overview of Linux kernel I/O mechanisms, including file system interfaces, blocking and non‑blocking I/O, asynchronous models, multiplexing with select/epoll, EXT file‑system structures, VFS abstraction, consistency and journaling, as well as the complete block I/O path, scheduling algorithms, and debugging tools.
This article explains why SQL queries become slow, how to capture slow queries using MySQL's slow query log, and provides detailed step‑by‑step methods for analyzing execution plans, profiling, optimizer tracing, and I/O parameters to identify and resolve performance bottlenecks.
Linux I/O models range from synchronous native operations to asynchronous kernel‑bypass techniques, with APIs such as open, read, write, mmap, sendfile and splice, while the modern io_uring interface—supporting interrupt, polling, and kernel‑polling modes via liburing—delivers superior performance, especially at high queue depths, compared to traditional libaio.
The article explains how different storage media affect I/O speed, describes kernel and user mode separation, introduces DMA and zero‑copy techniques such as mmap + write and sendfile, and discusses PageCache behavior, advantages, drawbacks, and tuning for high‑performance file transfers.
This article explains the concepts of synchronous vs asynchronous and blocking vs non‑blocking I/O, then details the characteristics, advantages, and drawbacks of Java’s three I/O models—BIO, NIO, and AIO—providing guidance on when to use each approach in backend development.
This article explains the concepts of synchronous vs asynchronous and blocking vs non‑blocking I/O, then compares Java's BIO, NIO, and AIO models, describing their mechanisms, advantages, drawbacks, and suitable usage scenarios for server‑side development.
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 Linux load average, covering how it is calculated, its relationship with CPU usage, and how the kernel exposes load data to applications.
This article explains how Linux handles I/O operations, covering the virtual file system, inode and dentry structures, superblock layout, ZFS features, disk types, the generic block layer, I/O scheduling strategies, and key performance metrics for storage.
This article examines Redis's transition from a single‑threaded reactor to a multi‑threaded I/O model, details the underlying I/O multiplexing and BIO subsystems, and explains the lazyfree mechanism for asynchronous large‑key deletions, providing extensive code analysis and performance insights.
This article explains how to monitor Linux system performance by covering CPU metrics with top and vmstat, memory usage via top columns and cache details, I/O health using iostat and zero‑copy techniques, as well as network statistics with sar, providing practical commands and interpretation guidance.
This article explains how to assess Linux system performance by examining CPU usage with top, interpreting load averages, using vmstat for detailed metrics, monitoring memory consumption via top, understanding cache behavior, evaluating I/O performance with iostat and sar, and provides practical commands and visual examples for each component.
This article explains Linux storage hierarchy, the roles of user‑space and kernel caches, the three‑layer I/O stack, page‑cache synchronization policies, file‑operation atomicity, locking mechanisms, and performance testing techniques for HDD and SSD devices.
This article provides a comprehensive guide to Java I/O, explaining the concepts of input and output streams, distinguishing byte and character streams, detailing node and processing streams, and offering practical code examples for file handling, buffering, conversion, and object serialization.
This article explains how Linux implements traditional system‑call I/O using read() and write(), details the data‑copy and context‑switch overhead of read and write operations, describes network and disk I/O, and introduces high‑performance techniques such as zero‑copy, multiplexing, and page‑cache optimizations.