This article explains the Cache Aside pattern, why deleting stale cache entries is often better than updating them, and presents a queue‑based lazy‑update solution that handles simple and complex consistency problems in high‑concurrency environments while outlining practical performance considerations.
This article explains why cache penetration and cache breakdown occur in high‑traffic systems and presents practical solutions such as null caching, Bloom filters, mutex locks, and asynchronous cache rebuilding, while discussing their advantages, limitations, and appropriate usage scenarios.
This article explains Redis transactions in depth, covering their command workflow, the MULTI/EXEC/DISCARD/WATCH/UNWATCH commands, error handling, practical code demonstrations, and a comparison with MySQL transaction semantics to help readers master Redis transaction usage for interviews and development.
This comprehensive guide explores Redis fundamentals, detailing its six primary data structures—strings, lists, hashes, sets, sorted sets, and streams—along with practical command examples, internal implementations, and usage patterns for high‑performance backend development.
This article explains Linux's memory architecture, the role of virtual memory and swap, the distinction between buffers and cache, and provides practical commands to adjust swappiness, clear caches, and safely release both RAM and swap space for improved system performance.
The article outlines common cache challenges—consistency, breakdown, and avalanche—explains traditional three‑tier architectures, then details Tencent Cloud Redis Hybrid Storage’s unified interface, automatic hot‑data caching, dynamic TTL, atomic updates, and cost‑effective persistence, offering a scalable, reliable cache‑plus‑storage solution.
This article explains a practical approach to validate test‑account login status by using a special syntax, per‑user locking, and thread‑safe caching to avoid repeated logins, while discussing transaction isolation levels and propagation settings needed for reliable backend testing.
This tutorial walks through preparing three CentOS 7 servers, installing and compiling Redis 6.0.3, configuring master‑slave replication, setting up Sentinel for high availability, adjusting firewall and Redis configuration, and managing the services to achieve a fully functional Redis cluster.
This article outlines comprehensive development guidelines for Alibaba Cloud Redis, covering key naming conventions, value design, command best practices, client usage patterns, related tools, and detailed code examples for safely deleting large keys across various data structures.
This article experimentally demonstrates how MySQL's table cache works, showing that it reduces file‑system reads of table definition files, operates per thread, and explains the recommended table_open_cache sizing formula based on concurrency and join complexity.
This article explains the purpose, differences, default settings, and practical verification of MyBatis first‑level and second‑level caches in Spring Boot, showing how cache scope, transaction boundaries, and mapper configuration affect cache behavior and performance.
This article explains how Redis uses memory, covering memory fragmentation analysis, object and buffer memory consumption, sub‑process memory overhead, and practical configuration of maxmemory limits and eviction policies to optimize performance and prevent out‑of‑memory failures.
This tutorial walks through compiling the php‑redis extension, installing Laravel, configuring Redis as a cache and database driver, setting up a Redis cluster, and provides sample PHP code for read/write operations, offering a comprehensive guide for backend developers.
This article explains GitLab CI cache configuration, including cache paths, keys, policies, and examples of global and job-specific caching, demonstrates pipeline execution and runner cache behavior, and provides best‑practice conclusions for effective CI/CD caching.
This article explains the necessity of virtual memory in modern operating systems, covering its role as an abstraction layer, caching benefits, memory protection, multi‑level page tables, process isolation, and how these mechanisms improve performance, security, and resource utilization.
This article explains the core components and operation of a CPU, covering the fetch‑decode‑execute cycle, instruction sets, registers, pipeline and superscalar designs, multi‑core and hyper‑threading concepts, and the hierarchy of caches from registers to L3, providing a comprehensive fundamentals overview.
This article introduces Redis as an open‑source in‑memory data‑structure store, explains its role as a NoSQL database, covers fundamental data types, common commands, expiration handling, and advanced features like pipelines and transactions, providing a comprehensive guide for developers.
This article provides a concise cheat sheet for Laravel's Cache system, detailing facade methods, helper functions, tagging, sections, store selection, and related events with ready-to-use code snippets, while noting version‑specific nuances such as the cache duration unit change in Laravel 5.8.
This article details a series of practical enhancements applied to an HBase 1.2.4‑based cluster—including layered BucketCache, data pre‑heating, GC‑friendly object pooling, and a multiget concurrency model—that together raise throughput several‑fold and consistently keep P99 latency below 50 ms in YCSB benchmarks.
The article explains why high‑traffic scenarios cause cache penetration, breakdown, and avalanche, and demonstrates practical solutions using Redis caching, empty‑object handling, Bloom filters, and locking techniques with detailed Java code examples.
Xianyu’s Flutter image pipeline was overhauled by using native ImageCache limits, a disk‑cache bridge, CDN‑driven resizing and WebP compression, precaching, ListView cacheExtent tuning, multi‑page texture recycling, and an external texture bridge, achieving substantial memory savings, reduced OOM risk, and a smaller app bundle.
This article explains why cache memory is essential for modern CPUs, how different loop orders affect cache hits, the structure of direct‑mapped, set‑associative and fully‑associative caches, multi‑level cache hierarchies, and the policies that govern cache allocation and updates.
This article explains the cache‑aside pattern, why deleting stale cache entries is preferred over updating them, outlines basic and complex cache‑database inconsistency scenarios, and presents a queue‑based solution with practical considerations for read‑blocking, request routing, and hotspot handling in high‑traffic systems.
This article explains how to optimize HBase performance by properly configuring JVM memory, selecting suitable garbage‑collection strategies, enabling MSLAB and BucketCache, and adjusting read/write cache ratios to reduce fragmentation and improve throughput.
During a performance test a query API failed on the second request because the Redis cache was written before asynchronous tasks finished, causing missing fields; the article explains the root cause, shows the original and fixed code, and details the debugging process.
CPU caches, organized into L1‑L3 levels, accelerate memory access by exploiting locality, but their independent copies can cause data inconsistency across cores; coherence protocols such as MESI and memory‑barrier instructions ensure that reads and writes remain ordered and visible across all processors.
This guide explains how Laravel handles session storage across HTTP requests, covering configuration files, built‑in drivers such as file, cookie, database, Memcached and Redis, custom driver creation, and common session operations like retrieving, storing, flashing, and regenerating IDs, with code examples throughout.
This article explains how a CPU executes programs through the fetch‑decode‑execute cycle, describes instruction sets, registers, pipelines, superscalar and multithreaded designs, and details the cache hierarchy from registers to L3, providing a comprehensive overview of modern processor fundamentals.
Redis creates 16 logical databases by default, a design inherited from its early architecture; this article explains the origin of that number, how to modify it via configuration, the proper way to view these databases as namespaces, and the limitations when using Redis in cluster mode.
This article outlines the essential design points for a local Java cache—including data structures, size limits, eviction policies, expiration handling, thread safety, blocking mechanisms, simple APIs, and persistence options—while providing concrete code examples and implementation guidance.
This article explains cache read and write mechanisms, the impact of operation order on data consistency, and presents optimization techniques such as delayed double deletion and binlog subscription to mitigate inconsistency in high‑concurrency backend systems.
This article analyzes a real‑world incident where Dubbo services continued to operate despite Nacos registry failures, explains the role of local provider caches, examines the namingLoadCacheAtStart configuration, and provides reproduction steps and best‑practice recommendations for high‑availability service discovery.
The article explains what Redis cache avalanche, penetration, and breakdown are, illustrates real‑world incidents, and provides pre‑, during‑, and post‑incident solutions such as high‑availability setups, local caches with rate limiting, fallback mechanisms, and placeholder writes to prevent database overload.
The article demonstrates how to enrich Flink streaming ETL jobs with slowly changing dimension data by periodically loading MySQL tables into an in‑memory cache and performing a simple map‑side join within a custom RichMapFunction implementation.
This article examines four common database architecture patterns—primary‑standby, dual‑primary, master‑slave read/write separation, and a hybrid dual‑primary + master‑slave—evaluating each against high availability, performance, consistency, and scalability, and then presents practical consistency‑resolution techniques and cache strategies.
This article provides comprehensive best‑practice guidelines for using Redis, covering data classification, key naming, size and connection limits, cache TTL, recommended client‑hash sharding, and a strict list of prohibited commands and operations to ensure performance, reliability, and maintainability.
The article explains the differences between cache and buffer, how Oracle’s log buffer and data buffer cache interact with various storage‑level caches, and why write‑back, battery‑backed caches, RAID and disk cache settings are crucial for maintaining data consistency during power loss.
This article explains the core principles of CPU operation, covering the fetch‑decode‑execute cycle, instruction sets, registers, pipeline and superscalar designs, multithreading and multicore behavior, as well as cache hierarchy from registers through L1‑L3, illustrating how these mechanisms affect program execution.
This article explains the hardware memory architecture, the role of caches, and how the Java Memory Model abstracts thread interaction with main and working memory, detailing the eight fundamental JMM operations, their ordering rules, and special considerations for long and double types to help developers write correct, high‑performance concurrent Java code.
This article explains how Redis removes expired keys using periodic and lazy deletion, describes the slave expiration handling, details the asynchronous memory reclamation commands like UNLINK and FLUSHALL ASYNC, and outlines the various maxmemory eviction policies including LRU, LFU, and their implementations.
This article presents a series of C‑based experiments that measure how sequential and random memory accesses behave across different array sizes and strides, revealing that random accesses can be up to four times slower than sequential ones due to cache and memory I/O effects.
This article presents a comprehensive analysis of Spark PageRank performance, detailing the algorithm's basics, the original example code, and four key optimizations—caching with checkpointing, memory‑efficient data structures, handling data skew, and maximizing executor and driver resource usage—backed by experimental results and practical recommendations.
When repeatedly performing Selenium actions causes the page to refresh slowly and occasional save errors, a custom forced‑refresh method using Ctrl+F5 and low‑level key events can reliably clear the cache and keep the automation stable.
The article dissects Glide’s five‑level caching system—active resources, memory cache, resource and data disk caches, and network cache—explaining how active weak references feed the LRU memory cache, how DiskCacheStrategy governs transformed and raw data storage, and how I/O and network tasks run on separate executors while network responses are cached before delivery.
This article explores Linux kernel memory management, detailing process address space allocation, the behavior of the OOM killer, various memory mapping types (shared, private, anonymous), cache usage, manual and automatic memory reclamation, and related kernel parameters, providing practical insights and examples.
This article examines common cache‑database consistency problems, explains why naive double‑write approaches fail, introduces the Cache‑Aside pattern, and proposes a queue‑based serialization solution with lazy cache updates to maintain data integrity under high‑traffic, concurrent read‑write workloads.
The article introduces the concept of full‑link mocking for complex, multi‑dependency applications, explains its technical background, describes the implementation architecture and performance considerations, and discusses practical challenges such as duplicate calls, cache consistency, and HTTP 302 forwarding.
This article explains how to achieve high‑throughput Redis caching with master‑slave replication, cluster scaling, disk‑less sync, incremental replication, and Sentinel‑based automatic failover to reach 99.99% availability and handle tens of millions of QPS.
The article explains what cache avalanche and cache penetration are in Redis, why they can crash databases, and provides practical strategies—including random expiration, high‑availability setups, local caches, rate limiting, Bloom filters, and empty‑object caching—to mitigate these issues and maintain cache‑database consistency.
This article explains how to achieve native‑app‑style page transition effects in a Vue.js SPA by using the vue‑navigation component to listen to router events, applying absolute positioning, managing a custom page cache, recording scroll positions, optimizing animation performance, and handling inter‑page communication with an EventBus.
This article explains how IO aggregation, RAID write penalties, and different workload models such as OLTP, OLAP, VDI, and SPC‑1 affect storage performance, covering concepts like read/write ratios, cache acceleration, and the impact of sequential versus random IO on bandwidth and IOPS.
This article introduces Redis as an open‑source in‑memory store, outlines its core data structures—strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, and geospatial indexes—and provides concrete command examples, application scenarios, and best‑practice guidelines for effective usage.
This article explains why cache clusters are essential, describes the problems caused by hot keys and large values, and presents a multi‑layer solution using streaming analytics, automatic hotspot detection, local JVM caching, and rate‑limiting to keep backend systems stable under massive traffic spikes.
This article explains why MyBatis may execute unexpected additional SQL statements, reveals the default caching behavior, shows the required XML configuration and Serializable implementation, and offers practical steps to prevent cache clearing on inserts for more efficient backend data access.
This guide walks you through installing Redis, adding Maven dependencies, configuring Spring Boot, creating a Redis service interface and implementation, and building controller endpoints to generate and verify SMS verification codes, complete with code examples and deployment instructions.
This guide presents comprehensive best‑practice recommendations for designing Redis keys, choosing appropriate data types, managing key lifecycles, safely using commands, optimizing client connections, handling big keys, and selecting eviction policies to ensure high performance and reliability in production environments.
This article explores Linux kernel memory management in depth, covering process address space layout, allocation mechanisms, OOM killer behavior, the whereabouts of allocated memory, and both manual and automatic memory reclamation techniques.
This article explains what a Progressive Web App (PWA) is, how Service Workers enable caching of static, dynamic, and HTML resources, and provides practical techniques such as precaching, offline‑package replacement, update strategies, and a webpack plugin to streamline integration for faster first‑screen loads.
This article explains the principles of caching, compares memory and disk storage, demonstrates several iOS persistence methods, and details how YYCache combines memory and disk layers with LRU optimization and network synchronization to improve performance in a real‑world mobile app.
Data Mill is a Spark‑Streaming‑based real‑time computation framework that abstracts tasks as DataFrames, enables SQL‑driven development, and supports DSP business requirements by reducing latency to 15‑30 minutes while providing a scalable architecture, caching strategy, and automated fault handling.
The article presents JD's self‑developed JMQ middleware, detailing its 2018 performance improvements, comparative benchmarks with Kafka, storage and index architecture evolution from JMQ2 to JMQ4, and the high‑performance I/O and caching strategies that enable millions of TPS on modern hardware.
This guide explains how to monitor critical Redis health indicators—including ping response, client connections, blocked clients, memory usage, fragmentation, cache hit rate, OPS, persistence status, expired keys, and slow logs—to ensure optimal performance and prevent failures.
This article explains the concept of cache breakdown, illustrates why malicious requests can bypass caches and overload databases, and presents three practical mitigation techniques—using a Redis SETNX‑based mutex lock, asynchronous cache rebuilding, and a Bloom filter—along with their advantages, drawbacks, and performance testing results.
This guide introduces Resilience4j, a lightweight Java library for implementing fault‑tolerance patterns such as circuit breakers, rate limiters, bulkheads, retries, caches, and time limiters, and shows how to configure each module with Maven and example code.
This article explains how Linux memory management differs from Windows, clarifies the output of the free command—including buffers and cache—and demonstrates the performance benefits of caching through a simple 1 GB file read experiment.
Youzan’s Transparent Multilevel Cache (TMC) adds automatic hotspot detection and a 64 MB local cache to existing distributed caches via a Hermes‑SDK‑augmented Jedis client, delivering transparent Java integration, strong consistency, up to 80 % local‑hit rates, and improved QPS during high‑traffic events.
This article provides a comprehensive introduction to Redis, covering its core concepts, advantages, data structures, persistence mechanisms, eviction policies, clustering, common usage scenarios, and typical interview questions for developers working with this high‑performance in‑memory key‑value store.
Linux appears to consume most of a system’s RAM, but the free command’s output, including buffers and cache, actually reflects memory used for performance optimization; this article explains the distinction, how to interpret free’s columns, and demonstrates the impact with a 1 GB file read experiment.
This article explains Linux kernel memory management from a global perspective, covering process address space layout, memory allocation mechanisms, OOM handling, the location of allocated memory, cache behavior, tmpfs usage, and the kernel's automatic memory reclamation strategies.
This article explores Linux kernel memory management, detailing process address space layout, allocation mechanisms, OOM handling, various mmap mappings, cache behavior, tmpfs usage, and the kernel's automatic memory reclamation strategies.
The article explains various cache problems—including consistency, concurrency, penetration, avalanche, and the bottomless‑pit phenomenon—and presents practical mitigation techniques such as active updates, locking, empty‑object caching, request filtering, consistent hashing, and multi‑level caching to ensure reliable high‑performance systems.
Through detailed debugging and source code analysis, the author discovers that MyBatis's SqlSession.clearCache() does clear the first‑level cache, but the observed stale query results are caused by MySQL's default REPEATABLE‑READ isolation level, which can be resolved by setting the transaction isolation to READ COMMITTED.
This article details Alibaba’s first production use of non‑volatile memory in the Tair MDB cache service, covering deployment, performance challenges such as write imbalance and lock overhead, the optimizations applied, and design guidelines for building NVM‑based caching systems.
This article examines three common cache‑update strategies, explains why some lead to data inconsistency, and proposes practical solutions such as delayed double‑delete, asynchronous retries, and message‑queue based recovery to maintain cache‑database consistency in high‑concurrency systems.
This article explains how Weibo handles massive daily traffic of over a hundred billion requests by employing a five‑layer feed system and a six‑layer cache architecture that evolved from simple KV storage to sophisticated counter and existence‑check services, highlighting design choices, performance optimizations, and future directions.
This article examines three common cache‑update strategies, explains their concurrency and performance drawbacks, and proposes practical improvement techniques such as delayed double‑delete, asynchronous retries, and binlog‑based messaging to maintain consistency between cache and database.
This article examines three common cache‑update approaches—updating the cache after the database, deleting the cache before updating the database, and updating the database then deleting the cache—analyzes their drawbacks, and presents practical solutions such as delayed double‑delete and retry mechanisms to ensure data consistency.
This article explains why distributed caching is essential for high‑traffic services, presents three programming approaches (direct code, Spring‑Data‑Redis injection, and annotation‑based), compares three cache‑access patterns, details sharding models, outlines smooth and offline migration steps, and addresses cache penetration, concurrency, avalanche, and transaction support with concrete code examples.
This article explains Linux kernel memory management, covering process address space layout, memory allocation, OOM handling, where allocated memory resides, and both manual and automatic memory reclamation techniques, with practical examples and visual illustrations.
This article translates hardware latencies—from CPU cache and memory to disk and network—into human‑scale time equivalents, using vivid analogies and benchmark data to illustrate why storage and networking appear extremely slow from the processor's viewpoint.
Linux’s free command often shows high memory usage, leading many to think the OS consumes RAM, but understanding buffers, cache, and the distinction between used and free memory reveals that Linux efficiently utilizes idle memory to improve I/O performance, as demonstrated by simple read‑speed experiments.
The article explains Chrome's guiding principles, multi‑process architecture, network request lifecycle, and a suite of performance optimizations—including DNS pre‑fetch, TCP pre‑connect, caching strategies, and predictive pre‑rendering—that together reduce latency and make the browser faster as users continue to browse.
The article thoroughly examines MyBatis’s first‑level (session) and second‑level (namespace) caches, detailing their configurations, internal workflows, source‑code implementations, experimental behaviors, common pitfalls such as stale or dirty data, and advises disabling built‑in caching in favor of dedicated solutions for production.
This article explains why Linux appears to consume most of the memory, clarifies the meaning of the free command’s buffers/cache fields, and demonstrates through a simple experiment how Linux’s caching dramatically speeds up repeated file reads.
An in‑depth comparison of Memcached and Redis reveals how both key‑value cache servers operate, covering their service models, event loops, memory allocation strategies, database implementations, persistence mechanisms, transaction support, and publish/subscribe features, highlighting the trade‑offs between simplicity and rich functionality.
This article explains the fundamentals of CDN, introduces QunarCache (CDN + Cache) architecture, compares cache solutions such as Squid, Varnish, ATS and Nginx, describes deployment patterns, operational monitoring, and future improvements for scalable, resilient content delivery.
This article explains various cache eviction strategies, compares heap, off‑heap, disk and distributed cache types, and provides concrete Java implementations using Guava Cache, EhCache 3.x and MapDB with code examples and usage patterns such as Cache‑Aside and Cache‑As‑SoR.
The article explains why Linux appears to consume most memory when using the free command, clarifies the roles of buffers and cache, shows how to interpret free’s output, and demonstrates through experiments how caching dramatically speeds up repeated file reads.
This article examines why Redis data can disappear, walks through a real incident where 90,000 keys vanished, and provides concrete monitoring, diagnostic, and preventive measures to avoid cache‑only and storage‑critical data loss scenarios.
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 article explains Linux kernel memory management, covering process address space layout, memory allocation methods, OOM killer behavior, where different types of memory reside, and both manual and automatic memory reclamation techniques, illustrated with diagrams and command examples.
This article explains why caching is essential, defines core concepts such as hits, misses, and costs, compares major replacement policies (LRU, LFU, FIFO, ARC, etc.), and provides Java code examples for implementing these algorithms in a backend system.
The article analyzes the massive scale of Chinese New Year red‑packet activity on WeChat, presents usage statistics, and explains the backend architecture—including distributed KV storage, cache‑layer atomic operations, and database transaction handling—that enables high‑throughput red‑packet distribution.
JIMDB is JD’s in‑house distributed cache platform that combines automatic fault detection, seamless online scaling, multi‑language support, and containerized deployment to replace traditional Memcached/Redis solutions, offering features such as one‑click cluster creation, elastic expansion, lossless scaling, and comprehensive monitoring for high‑traffic e‑commerce services.
This article summarizes common Redis cache update problems, compares four update approaches—including proactive, passive, and pre‑loading methods—and recommends a pre‑load strategy with key versioning to avoid data loss, improve performance, and reduce memory waste.
This article reviews the evolution of distributed locking—from simple MySQL table locks to Redis cache locks and the Redlock algorithm—examines expert criticisms of Redlock’s correctness, presents the Redis author’s rebuttal, and ultimately recommends Zookeeper as a more reliable solution for high‑availability distributed locks.
A multi‑person technical discussion explores the reasons behind low cache hit rates, examines memcached LRU mechanisms, proposes AOP‑based caching strategies, and shares practical solutions such as proactive cache invalidation, lock‑based stampede protection, and workload‑aware configuration for backend systems.
This article explains how traditional ACID transactions fall short for modern large‑scale systems and presents lock‑free transaction methods, atomic and partial cache‑switch techniques, and a PostgreSQL‑style MVCC model for key‑value databases, including practical rules and trade‑offs.
The article details how Weibo’s cache infrastructure progressed from simple Memcache deployments to a sophisticated, service‑oriented architecture featuring multi‑layer caching, proxy layers, dynamic configuration, monitoring, and automated scaling to meet massive read‑write demands and high availability requirements.
The article explains how Redis replicas can return keys that should have expired due to the master‑only expiration process, describes the three expiration strategies (lazy, periodic, active), and offers practical solutions such as using SCAN or upgrading to Redis 3.2 to avoid stale reads.
