This article explains the concepts, working principles, and system parameters of Linux buffers and cache, compares their roles in read/write operations, and provides practical vmstat and dd command examples to illustrate how they affect memory usage and I/O performance.
This article explains how send and receive socket buffers work, why they are crucial for TCP flow and congestion control, how to tune kernel parameters and application settings, and what common pitfalls and testing methods help keep network services stable and efficient.
This article explains the inner workings of Caffeine's cache, covering the getIfPresent method, the design of ReadBuffer and StripedBuffer, eviction policies, the maintenance cycle, and the climb algorithm that dynamically adjusts window and protected partitions for optimal performance.
This article explains MySQL 8.0.32's binlog log file structure, the 8 KB in‑memory buffer (IO_CACHE), how binlog entries are written from trx_cache to the binlog file, and the detailed steps and code involved in reading from memory or temporary files and flushing to disk.
This article explores Netty’s low‑level data container ByteBuf by examining Java NIO Buffer design, its core attributes, view mechanisms, heap and direct implementations, byte‑order handling, and how to read and write primitive types, providing a comprehensive foundation for high‑performance network programming.
This article builds a simple two‑VM testbed to explore how Linux socket buffer parameters affect TCP throughput, demonstrates baseline speeds, adds artificial network delay, analyzes the bandwidth‑delay product, and shows how tuning tcp_wmem, tcp_rmem and related sysctl settings can recover performance on high‑latency links.
This article explains the fundamental differences between buffers and caches, details MySQL’s multi‑layer buffer architecture, and examines how write‑through, write‑back, and Direct I/O affect data durability and performance through various InnoDB flush parameters.
This article explains the definitions of Linux buffers and cache, how the free command reports them, and demonstrates through experiments that buffers can cache both reads and writes while cache primarily handles page caching for file reads and writes.
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.
This article explains Java NIO buffers, covering how to create them with allocate() and allocateDirect(), describing their four core properties (position, limit, capacity, mark), and detailing essential methods such as put(), get(), flip(), rewind(), clear(), mark(), reset(), hasRemaining() and remaining() with code examples.
This article provides a comprehensive overview of Java NIO, explaining the differences between BIO and NIO, the concepts of synchronous/asynchronous and blocking/non‑blocking I/O, and detailing the usage and implementation of Buffers, Channels, and Selectors with code examples.
This article provides a comprehensive guide to Java NIO, covering its core components—Channel, Buffer, and Selector—explaining the differences from traditional IO, demonstrating file, socket, and server implementations with detailed code samples, and illustrating advanced features such as memory‑mapped files, scatter/gather, and pipe communication.
This article provides a comprehensive guide to Redis high‑availability through master‑slave replication, covering the underlying architecture, step‑by‑step setup, full and partial synchronization processes, buffer management, practical pitfalls, and how the mechanism fits into broader Redis HA solutions.
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.
This article provides a concise, visual explanation of the fundamental differences between cache and buffer, illustrating their distinct roles—cache for speeding data retrieval and buffer for smoothing data flow—through real‑world analogies, hardware examples, and practical usage scenarios.
This article provides a comprehensive source‑level examination of Go's channel mechanism—including usage examples, the internal hchan data structure, creation, read/write operations, closing behavior, and common pitfalls—based on the Go 1.14 runtime implementation.
This article explains what Go channels are, how they are implemented in the runtime, their data structures, creation, sending, receiving, closing semantics, common pitfalls, and includes detailed code examples to illustrate channel behavior in concurrent programs.
This comprehensive guide explores Node.js Buffer fundamentals, binary data handling, stream integration, memory allocation mechanisms, practical usage scenarios, and performance benchmarks, providing developers with the knowledge to efficiently manage binary streams and boost application speed.
This article analyses why seemingly normal PHP‑FPM requests can cause Nginx to return 502 errors, revealing a FastCGI fastcgi_buffer_size bug triggered by warning output, describing the reproduction steps, detailed packet analysis, the underlying protocol mechanics, and practical recommendations for developers and operators.
This tutorial explains how to dynamically control WebGL vertex and fragment shaders by using attribute and uniform variables, assign values from JavaScript, manage buffer objects for large vertex datasets, and render multiple points with proper WebGL API calls.
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 how Java byte streams operate directly on files without buffering while character streams use an intermediate buffer, demonstrates the effects with code examples, and discusses when to use each stream type in practice.
This article explains the most common Oracle wait events—including buffer busy waits, buffer latch, control file parallel write/read, various DB file reads and writes, latch free, and library cache lock—detailing their causes, parameters, and how to query them for performance analysis.
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 guide explains Linux memory reporting with the free command, the roles of buffer and page caches, and provides step‑by‑step instructions to manually release cached memory using /proc/sys/vm/drop_caches, including practical command examples and clarifications of key concepts.
This guide walks through securing an Nginx web server by configuring buffer size limits, timeouts, concurrent connection controls, host and method restrictions, user‑agent blocking, hot‑link protection, directory access rules, SSL setup, PHP hardening, chroot isolation, and firewall‑level IP connection limits.
This article presents a systematic overview of web caching, detailing a seven‑layer cache hierarchy, clarifying the differences between buffer and cache, and explaining key cache metrics and design considerations for modern web architectures.
This article explains the Linux TCP connection‑establishment, packet‑receive, and packet‑send paths, categorizes related kernel parameters such as backlog, SYN‑cookie, ring buffers, and socket buffers, and provides practical commands and guidelines for optimizing network performance on servers.
