OPPO’s data‑lake team, led by David, detailed their transition from Hive‑Spark to a unified multi‑modal lake, leveraging Gravitino for cross‑engine metadata management and the open‑source Curvine cache to eliminate data silos, boost I/O performance, and support massive image, recommendation, and AI‑Agent workloads.
This article walks through designing and implementing GoMemcache, a lightweight Go‑based distributed cache, covering use‑case selection, concurrency lock optimization, consistent hashing, production‑grade code, and practical deployment best practices for ultra‑low latency services.
JIMDB, a Redis‑based distributed cache, introduces the Big‑Hot Key concept and a multi‑layer proactive governance framework that dynamically identifies resource‑intensive keys, automatically mitigates them, and delivers up to an 80% performance gain while dramatically improving system stability.
This article details the architecture, key concepts, features, and design formulas of PoleFS’s BlobCache distributed caching subsystem, explaining how it achieves high performance, reliability, scalability, multi‑tenant isolation, and elastic capacity within a cloud‑native file system.
This article explains why caching is a performance trade‑off, outlines essential cache features such as size limits, eviction policies, TTL, configuration, integration APIs, and distributed versus local modes, and provides a comprehensive checklist for evaluating cache providers.
This article outlines the key building blocks of a microservice architecture—including Nginx as the traffic entry, Spring Cloud Gateway, service registries, Redis caching, MySQL persistence, Elasticsearch, message queues, ELK logging, distributed schedulers, and object storage—explaining their roles, deployment patterns, and common technology choices.
Coupang’s AI platform replaces costly data‑copy steps with a distributed cache that automatically pulls data from a central lake, boosts GPU utilization across regions, cuts storage and operational expenses, and speeds up model training by up to 40% while simplifying deployment via Kubernetes.
The article explains how to design a scalable, highly available backend system capable of handling millions of requests per second by defining key performance metrics, estimating traffic with the 2/8 rule, and applying architectural patterns such as load‑balanced clusters, vertical service splitting, distributed caching, and database master‑slave replication, illustrated with a Taobao case study.
This article explains why traditional relational databases falter under high‑concurrency loads, introduces caching as a solution, compares Redis distributed caching with local in‑process caching, and shows how combining them into a multi‑level cache can dramatically improve performance and reliability.
The article explains the design and implementation of the Serverless Application Engine (SAE) Event Center, highlighting its cloud‑native architecture, the distinction from traditional monitoring, challenges like data explosion and full GC, and the distributed‑cache solution that enables efficient real‑time event aggregation, notification, and future AI‑driven diagnostics.
This article explains four typical cache problems—penetration, avalanche, breakdown, and distributed cache efficiency—describing their causes and offering practical mitigation strategies such as top‑level filtering, Bloom filters, staggered expirations, null caching, and locking mechanisms.
This article provides a comprehensive guide to backend caching, covering fundamental concepts, usage scenarios, read‑through and cache‑aside strategies, local and distributed cache types, popular services like Redis and Memcached, eviction algorithms such as FIFO, LRU, LFU, and common issues like consistency, avalanche, penetration, and stampede, along with practical mitigation techniques.
An in‑depth guide to backend caching covers read‑through and cache‑aside strategies, local versus distributed caches (including Redis and Memcached), eviction algorithms such as FIFO, LRU and LFU, and tackles consistency, avalanche, penetration and breakdown issues with practical mitigation techniques.
This article explains the motivation, design principles, class diagram, and core Go code for a multi‑level cache library that supports in‑memory and distributed caches (Redis, Memcached) using adapter, builder, and responsibility‑chain patterns, and discusses cache‑database consistency strategies.
This article explains what high concurrency is, why it matters for large‑scale systems, and presents practical techniques such as distributed caching, load balancing, database optimization, traffic shaping, and distributed architecture to dramatically improve a backend's ability to handle massive simultaneous requests.
This article explains the core design goals, sharding strategies, replication models, communication protocols, cache selection, and monitoring techniques needed to build high‑performance, highly available, and scalable distributed cache systems for large‑scale internet applications.
This article presents REDTao, Xiaohongshu's self‑built graph storage solution that unifies graph queries, reduces development duplication, and delivers low‑latency, high‑availability access to a trillion‑scale social graph through a three‑layer architecture, distributed cache, and cloud‑native deployment.
Alluxio Edge is a library that runs inside Trino or PrestoDB workers, using local SSD or memory to cache data from cloud storage, which restores data locality, cuts storage egress, and delivers up to ten‑fold IO speed gains and up to ten‑fold query performance improvements in real deployments.
Redis serves as a powerful in‑memory key‑value store for distributed caching, offering various data structures, persistence options, deployment modes, eviction policies, and update strategies, while addressing consistency challenges, cache miss scenarios, and failure modes such as penetration, breakdown, and avalanche.
This article explains why caching is crucial for Spring Boot applications, examines its impact on microservice architectures, outlines criteria for selecting the right cache—usability, speed, availability, observability—and compares local, distributed, and hierarchical caches with practical strategies and code examples.
This article details how a major bank designed and implemented a distributed Redis cache platform that enables fast deployment, centralized management, elastic scaling, high availability, automated operations, and comprehensive monitoring to support agile development and efficient operations.
This article details the design and implementation of REDtao, a self‑built graph storage system for Xiaohongshu that replaces MySQL with a three‑layer architecture, distributed cache, cross‑cloud multi‑active support, and delivers trillion‑edge scale, 150 M QPS, 90% cache hit rate, and significant cost reductions.
Ximalaya’s KV storage progressed from a simple Redis master‑slave setup to client‑side sharding, then adopted Codis clustering for elastic scaling, integrated Pika’s disk‑based store with cold‑hot separation, introduced KV‑blob separation, fast‑slow command pools, second‑level expansion, ehash fields, large‑key circuit breaking, multi‑active data‑center replication, and now targets cloud‑native deployment, advanced features, and AI‑driven operations.
This article outlines the design goals, architecture, and implementation details of a high‑performance distributed caching solution for Spring Boot applications, combining Redis as a first‑level cache with Caffeine as a second‑level cache, and provides configuration, usage examples, and future enhancement plans.
An in‑depth case study shows how GPT‑4, demonstrated by former Google engineer Naman Bhalla, tackles a simulated Uber interview by generating software requirements, design specifications, Java code snippets, and JUnit tests for a distributed cache system, revealing both its strengths and current limitations.
This article explains what caching is, outlines various cache types, analyzes common high‑traffic cache issues such as penetration, breakdown, avalanche, and hot‑key handling, and presents real‑world architectures from Weibo and Zhihu to illustrate effective cache design and operation.
This article examines the storage bottlenecks in large‑scale AI training, evaluates local‑disk and Alluxio‑based distributed caching strategies, proposes uniform cache eviction and replica‑aware global policies, and introduces the SiloD framework for coordinated compute‑storage scheduling to dramatically improve GPU utilization and overall cluster throughput.
This article explores how caching accelerates high‑concurrency systems by reducing CPU and I/O load, compares local and distributed cache types, reviews Java cache implementations and frameworks, and presents real‑world multi‑level cache designs and pitfalls to help you select the optimal solution.
This article explains the fundamentals, characteristics, and use‑cases of distributed caching, compares Memcached and Redis, and provides a step‑by‑step Spring Boot implementation with code samples, testing guidance, and solutions to common cache pitfalls such as hot keys, penetration, and avalanche.
Cache stores frequently accessed hot data in memory to reduce database load, improving performance and handling high‑concurrency scenarios; this article explains cache fundamentals, why Redis is preferred, classifications such as local, distributed, and multi‑level caches, their advantages, drawbacks, and implementation tips.
This article explains the fundamentals of caching, why caches (especially Redis) are essential for high‑performance and high‑concurrency scenarios, compares local, distributed, and multi‑level caches, and outlines their advantages, disadvantages, and typical implementation approaches.
This article explains the fundamentals of caching, why caches (especially Redis) are essential for high‑performance and high‑concurrency scenarios, describes local, distributed, and multi‑level cache architectures, outlines their pros and cons, and provides practical implementation guidance.
This article explains the concept of caching, compares it with buffering, outlines common scenarios such as memory, SSD, static, distributed and local caches, discusses their advantages and limitations, and provides a Java Guava Cache example for practical backend performance optimization.
This article explains the fundamentals of consistent hashing, its application in load‑balancing distributed caches, analyzes common issues such as data skew and cache avalanche, introduces virtual nodes for uniform distribution, provides Java code examples, and compares it with Redis's HashSlot approach.
This article provides an in‑depth overview of caching, covering its definition, when to use it, core concepts, various cache types (client, server, CDN, reverse‑proxy, in‑process, distributed), eviction policies, multi‑level cache architectures, common pitfalls such as cache avalanche, penetration and breakdown, and practical mitigation techniques.
This article explains how Zuoyebang redesigned its massive data retrieval platform by separating compute and storage with the Fluid project on Kubernetes, achieving minute‑level hundred‑TB distribution, elastic caching, and improved stability for real‑time educational services.
This article explains why caching is essential for reducing CPU and I/O pressure, outlines key cache attributes such as throughput and hit rate, compares popular local cache libraries, describes distributed cache options, and details the design, consistency, monitoring, and hot‑key handling of a transparent multilevel cache architecture.
Server‑side caching improves performance by trading space for time, using local caches like HashMap, Guava, Ehcache, and Caffeine, distributed caches such as Redis, and multi‑level architectures that combine in‑process, distributed, and database layers, while employing consistency patterns, monitoring, and hot‑key detection.
This article presents a comprehensive technical overview of Alluxio, covering its role as a distributed data orchestration layer for AI workloads, core features such as caching and unified namespace, performance challenges in large‑scale machine‑learning pipelines, and the extensive optimizations and testing performed at Tencent to achieve high throughput and scalability.
This article details Ctrip Finance's design and implementation of a unified high‑availability Redis‑based distributed cache, covering eventual and strong consistency scenarios, multi‑region deployment, lock mechanisms, message‑driven updates, failure handling, and performance results.
This article examines the characteristics of Redis and Memcached as distributed cache solutions, outlines common design pitfalls such as consistency, cache penetration, breakdown, avalanche, and hot‑key issues, and provides practical strategies—including consistent hashing, binlog‑driven invalidation, message‑queue indexing, and lock mechanisms—to build reliable and high‑performance caching layers in backend systems.
This article examines the landscape of cache systems, compares four major categories, evaluates popular distributed caches such as Redis, Memcached, Tair and EvCache, explains Redis Cluster architectures and sharding strategies, and outlines common cache pitfalls with practical mitigation techniques.
This article reviews various cache system types, compares popular distributed caches such as Memcache, Tair, and Redis, explains Redis cluster high‑availability mechanisms, discusses sharding strategies, and outlines common cache problems and solutions, providing practical configuration examples for Java backend developers.
This article presents Ctrip Finance's design of a unified high‑availability Redis cache service, covering both eventual‑consistency and strong‑consistency scenarios, the overall architecture, data‑accuracy, completeness and availability mechanisms, lock handling, fault‑tolerant updates, and operational recovery strategies.
This article explains why caching is used, distinguishes between local and distributed caches, compares popular Java cache libraries, describes Redis and Memcached differences, outlines the Cache‑Aside pattern, and discusses common cache problems such as inconsistency, penetration, breakdown, avalanche, hot‑key detection, and their mitigation strategies.
This article explores the fundamentals and advanced techniques of cache optimization, covering multi‑level caching, read/write performance gains, cache miss handling, consistency strategies, heap versus direct memory, CPU cache effects, false sharing, and practical mitigation patterns.
In high‑traffic e‑commerce systems, caching—ranging from simple in‑JVM HashMap caches to Guava, Caffeine, and Redis distributed stores—reduces latency by applying eviction policies such as FIFO, LRU, LFU, or W‑TinyLFU, while employing consistency strategies like expiration, write‑through, and cache‑aside to mitigate breakdown, avalanche, and penetration issues.
This article examines why accelerating cloud‑based deep learning is essential, presents benchmark results comparing GPU generations and distributed training, introduces Alluxio as a distributed memory‑level cache, details its architecture on Kubernetes, and offers concrete tuning strategies to overcome I/O bottlenecks and boost training performance.
This article explains what data lineage is, why it is essential for data governance in large‑scale big‑data platforms, compares Apache Atlas with a custom solution, and details the technical choices, architecture, and performance optimizations behind the self‑built duo‑lineage system.
This article analyzes the characteristics of Redis and Memcached, explains typical design mistakes such as inconsistent hashing, cache avalanche, penetration, and hot‑key issues, and provides practical solutions like consistent hashing, binlog‑driven cache invalidation, key versioning, and distributed locking to improve cache reliability and performance.
This article shares a senior architect’s ten‑year journey with caching, covering local page and object caches, refresh policies, distributed solutions like Redis and Memcached, pagination caching techniques, multi‑level cache architectures, common pitfalls, and practical optimization lessons for high‑performance backend systems.
This article shares a senior architect’s decade‑long journey with caching, covering page‑level and object caches, refresh mechanisms, distributed solutions like Redis and Memcached, pagination caching techniques, and multi‑level cache architectures, while highlighting practical pitfalls and performance gains.
Cache leverages the space‑time trade‑off to boost performance, but introduces complexity; this guide explains its fundamental idea, local vs distributed solutions, popular Java caching libraries, and key read/write patterns such as Cache‑Aside, Read‑Through, and Write‑Behind, highlighting benefits, drawbacks, and best‑practice considerations.
This article explains the classic Cache‑Aside pattern, analyzes common cache‑database consistency problems in high‑traffic systems, and presents practical solutions—including delete‑first updates, internal JVM queues, lazy recomputation, and routing considerations—to ensure reliable data synchronization under heavy concurrency.
This article explains why caching is essential for Java distributed applications, introduces Redis as an in‑memory data store, and demonstrates how the Redisson framework provides distributed cache implementations—including RMapCache, Spring Cache integration, and JCache support—complete with code examples and configuration details.
This tutorial explains how to configure EhCache for distributed caching in a Spring Boot application, covering serialization, XML cluster settings, deployment parameters, REST endpoints for testing, and strategies to keep cache data consistent across multiple JVM instances.
The article details Ctrip's challenges with multiple AB testing splitters, presents performance gains after migrating to a new splitter, and explains the comprehensive redesign covering overall architecture, interface consolidation, SDK slimming, and a custom distributed cache backend to achieve higher throughput and lower latency.
This article explains the concept of consistent hashing, its application in distributed cache load balancing, analyzes issues like data skew and cache avalanche, presents virtual‑node optimizations with Java test code, discusses graceful scaling strategies, and compares it to Redis’s HashSlot and P2P approaches.
This article explains why caching is essential for Java distributed applications, introduces Redis and Redisson, and demonstrates how to implement distributed caches using Redisson Maps, Spring Cache integration, and the JCache API with practical code examples.
This article explores the pervasive role of caching in modern systems—from browser and HTTP caches to CDN, load‑balancer, in‑process, and distributed caches—detailing their mechanisms, algorithms, common pitfalls like cache avalanche, penetration and breakdown, and practical mitigation techniques for robust backend performance.
To achieve low‑latency, high‑throughput data access in systems like Gaode’s navigation service, the article advises evaluating CPU and I/O bottlenecks, choosing between local (HashMap/ConcurrentHashMap or Caffeine) and distributed caches (Redis preferred), applying appropriate eviction, TTL, and consistency patterns, and mitigating cache penetration, breakdown, and avalanche risks.
The article presents a detailed analysis of Weibo's short‑video platform architecture, covering team background, business scenarios, micro‑service design, feed‑pull model, multi‑level distributed caching, multi‑datacenter HA deployment, circuit‑breaker mechanisms, and elastic scaling to achieve high availability under unpredictable traffic spikes.
This article presents a comprehensive overview of Alibaba's Time Series Database (TSDB), covering its business panorama, covered scenarios, challenges, performance evolution, architecture, core compression and query technologies, stability mechanisms, and future development plans.
This article explains Flink's distributed cache feature, describes its registration and retrieval mechanisms, and provides a complete Java example that demonstrates how to register a file, access it within a RichMapFunction, and print the processed results.
This article explains cache fundamentals—from CPU and local caches to distributed systems—covers design principles, performance‑affecting factors, eviction algorithms, and common high‑concurrency issues such as penetration, stampede, and avalanche, and provides practical solutions for selecting and optimizing cache strategies.
This article explains when caching is needed, how to choose appropriate in‑process and distributed caches, design multi‑level cache architectures, handle cache updates, avoid common pitfalls such as penetration, breakdown and avalanche, and provides practical advice on serialization, GC tuning, monitoring, and framework selection.
This article explains why cache design is essential for high‑concurrency systems, compares CPU and application caches, outlines multi‑level and distributed caching strategies, discusses write‑through/write‑behind patterns, cache synchronization methods, penetration protection, and eviction policies to alleviate database pressure.
This article explains why distributed caching is essential for high‑concurrency systems, outlines typical use cases, compares Memcached and Redis across features and performance, and discusses common problems such as cache avalanche, penetration, warm‑up, update strategies, and degradation.
This article explains the motivation behind cache design, compares CPU and application‑level caches, discusses multi‑level and distributed caching, outlines synchronization methods, eviction policies, and answers frequent cache‑related questions to help reduce database load and improve system performance.
Alibaba’s Tair, a high‑performance distributed key/value cache, evolved through multiple versions to support massive traffic during Double 11, employing multi‑region deployment, hotspot hashing, memory merging, user‑space networking, and client optimizations that dramatically cut latency, improve scalability, and reduce operational costs.
This article explains the fundamentals of caching, why it is essential for high‑traffic web services, compares cache components such as Memcached and Redis, and details design patterns, scalability, high‑availability, and operational practices for building robust distributed cache systems.
The article explains EMC vPlex's evolution, dual‑active Metro and Geo configurations, distributed cache coherence, storage virtualization, and integration with RecoverPoint, highlighting how these technologies enable high‑availability, low‑latency data access across multiple data‑center sites.
This article explains how website systems achieve scalability through architectural designs such as physical function separation, server clustering, various load‑balancing techniques, distributed cache mechanisms, and both relational and NoSQL database scaling methods, providing practical guidance for large‑scale web deployments.
This article explains common problems of distributed caching such as cache breakdown, cache expiration, and hot‑key bottlenecks, and provides practical mitigation techniques including default null values, staggered expiration times, distributed locking, client‑side caching, and key sharding to maintain high‑concurrency performance.
This article explains how to achieve website scalability through physical separation, server clustering, various load‑balancing techniques, consistent‑hashing for distributed caches, and scaling strategies for relational and NoSQL databases, providing practical guidance for building resilient back‑end systems.
This article explains how startup engineers can design a scalable web system by separating services onto multiple servers, using load balancers, distributed caches, master‑slave replication, and team‑splitting strategies, ensuring performance and reliability as user traffic and data volumes surge.
This article breaks down the core architecture, request protocols, and memory management mechanisms of Memcached and Redis, comparing their server models, highlighting their strengths and trade‑offs, and offering practical guidance for selecting and tuning these distributed caching solutions.
This article explains the concept of Single Sign-On (SSO), why it’s essential for large web platforms, the core steps of storing and validating trust, common cookie‑based approaches, their security drawbacks, and how server‑side solutions using distributed caches and digital signatures can provide a robust, cross‑domain authentication system.
The article analyzes the use of a master/slave architecture for distributed caching, explains why two clusters, CAS, and proxy are employed, discusses consistency and availability challenges, and evaluates possible mitigation strategies for cache failures.
This article presents an in‑depth overview of Codis and its next‑generation project RebornDB, covering Redis, Redis Cluster, the proxy‑based architecture, consistency trade‑offs, production deployment experiences, operational pitfalls, and broader perspectives on distributed databases and architectures.
This interview with JD’s distributed cache and NoSQL lead reveals how JimDB evolved from a Redis‑based engine to a two‑tier SSD‑optimized key‑value store, detailing fault‑tolerant design, online migration, scaling strategies, and the shifting role of DBAs in massive e‑commerce traffic.
