BestHub
Sign in
Tagged articles

cache

547 articles · Page 1 of 6
IT Learning Made Simple
IT Learning Made Simple
Aug 14, 2026 · Fundamentals

Why the Von Neumann Architecture Is the ‘Relativity Theory’ of Computing

The article explains how the von Neumann architecture, introduced by John von Neumann in 1945, established the stored‑program concept that underpins all modern computers, describes its five core components, the classic CPU‑memory bottleneck, and the cache, pipeline and parallel techniques used to mitigate it, while contrasting it with the Harvard architecture and offering everyday analogies.

CPU bottleneckHarvard architecturecache
0 likes · 6 min read
Why the Von Neumann Architecture Is the ‘Relativity Theory’ of Computing
Cloud Architecture
Cloud Architecture
Aug 12, 2026 · Databases

How Redis Cluster’s Decentralized Design Powers Billion‑Scale Traffic

When a single Redis instance can no longer hold the data volume or write load of e‑commerce workloads, the traditional master‑slave with Sentinel model reaches its limits, and Redis Cluster—by sharding data across 16,384 slots, using gossip‑based topology, and removing a central control plane—delivers horizontal scaling and fault‑tolerance for billions of requests, provided key design, hash tags, hot‑key mitigation, and client routing are applied.

ClusterHigh AvailabilityRedis
0 likes · 32 min read
How Redis Cluster’s Decentralized Design Powers Billion‑Scale Traffic
java1234
java1234
Aug 11, 2026 · Backend Development

Why More Developers Are Choosing Guava for Java Projects

Guava, Google’s core Java library, offers a rich set of utilities—immutable collections, null‑safe string handling, local caches, and concurrency helpers—that reduce boilerplate, prevent bugs, and integrate with a single Maven/Gradle dependency, making it a popular choice for modern Java backend development.

Google Core LibrariesGradleGuava
0 likes · 9 min read
Why More Developers Are Choosing Guava for Java Projects
YiSu Grain
YiSu Grain
Aug 7, 2026 · Fundamentals

40 Comprehensive System, Network, and Management Questions – Day 49 Review

A detailed walkthrough of 40 practice questions covering CPU execution time, pipeline theory, cache locality, bus bandwidth, address space, DMA, RAID levels, threading, paging, producer‑consumer synchronization, deadlock conditions, page‑replacement anomalies, networking fundamentals, project‑management metrics, standards, and intellectual‑property basics, complete with explanations and formulas.

NetworkingOperating SystemsProject Management
0 likes · 49 min read
40 Comprehensive System, Network, and Management Questions – Day 49 Review
samdeepthink
samdeepthink
Aug 3, 2026 · Backend Development

Is the Classic Update‑DB → Delete‑Cache → TTL Pattern Really the Best Way to Keep Cache Consistent?

The article examines why the common update‑database, delete‑cache, add‑TTL workflow can still produce permanent stale data under high concurrency, explains the underlying race conditions, and compares several alternative strategies—including delete‑first, binlog‑driven invalidation, and lease‑based approaches—to help engineers choose the most reliable and low‑complexity solution for cache consistency.

Cache AsideMySQLRedis
0 likes · 19 min read
Is the Classic Update‑DB → Delete‑Cache → TTL Pattern Really the Best Way to Keep Cache Consistent?
Mike Chen Rui
Mike Chen Rui
Jul 31, 2026 · Backend Development

Boost Nginx Cache Performance by 10×: Key Techniques Explained

The article explains how Nginx caching can dramatically improve web service performance—up to tenfold—by detailing the cache's core mechanisms, practical configuration parameters, and best‑practice strategies such as cache keys, expiration policies, lock handling, stale fallback, and header management.

ConfigurationNginxProxy Cache
0 likes · 5 min read
Boost Nginx Cache Performance by 10×: Key Techniques Explained
YiSu Grain
YiSu Grain
Jul 29, 2026 · Fundamentals

Day 43: Understanding Computer Architecture – CPU, Cache, Bus, I/O and RAID

This article explains the core components of a Von Neumann computer, how CPU, registers, cache and main memory interact, the mathematics of pipeline timing, cache locality, bus bandwidth calculation, I/O transfer methods (polling, interrupt and DMA), and the trade‑offs of RAID 0, 1, 5, 6 and 10 with concrete examples and formulas.

BusCPUI/O
0 likes · 44 min read
Day 43: Understanding Computer Architecture – CPU, Cache, Bus, I/O and RAID
samdeepthink
samdeepthink
Jul 17, 2026 · Databases

Designing Redis Leaderboards: From a Single ZSet to Billion‑Scale Rankings

The article walks through the evolution of Redis leaderboard architectures, covering why ZSets are used, handling same‑score ordering, seasonal resets, access patterns, synchronous vs asynchronous updates, big‑key and hot‑key issues, sharding with buckets, and data durability strategies.

AsynchronousLeaderboardRedis
0 likes · 12 min read
Designing Redis Leaderboards: From a Single ZSet to Billion‑Scale Rankings
Cloud Architecture
Cloud Architecture
Jul 16, 2026 · Backend Development

Beyond Delayed Double Delete: How CDC Closed‑Loop Governance Solves Cache Consistency

The article dissects why the classic "update‑DB‑then‑delete‑cache" or its reverse is only a probability fix for cache inconsistency, demonstrates the failure modes of delayed double delete under high load and replication lag, and presents a production‑grade solution built on Binlog CDC with versioning, four‑plane governance, and robust error handling to achieve reliable cache synchronization.

CDCVersioningbackend
0 likes · 36 min read
Beyond Delayed Double Delete: How CDC Closed‑Loop Governance Solves Cache Consistency
Programmer DD
Programmer DD
Jul 12, 2026 · Artificial Intelligence

Which Chinese LLM Provider Has the Most Stable Cache for Running Agents?

Based on real‑world request logs collected via octafuse‑gateway, the article compares cache hit rates and availability of major Chinese LLM vendors, showing that official model providers (e.g., DeepSeek, Xiaomi MiMo, Zhipu) achieve over 90 % hit rates, while cloud MaaS and Volcano Ark lag behind, especially in high‑frequency Agent scenarios.

AgentChinese ModelsCloud MaaS
0 likes · 6 min read
Which Chinese LLM Provider Has the Most Stable Cache for Running Agents?
YiSu Grain
YiSu Grain
Jul 7, 2026 · Fundamentals

Why Cache Isn't a Magic Bullet: How Redis Can Still Overload Your Database

The article explains how caching, especially with Redis, reduces database load in high‑traffic scenarios, but also details three cache failure modes—avalanche, penetration, and breakdown—and provides concrete mitigation techniques to keep systems stable.

Backend ArchitectureCache AvalancheCache Breakdown
0 likes · 13 min read
Why Cache Isn't a Magic Bullet: How Redis Can Still Overload Your Database
Code Farming
Code Farming
Jul 2, 2026 · Backend Development

Five Fatal Cache Pitfalls Explained with Five Diagrams

The article outlines five common cache design problems—penetration, concurrency, avalanche, hot‑data management, and business‑cache coupling—illustrates each with a diagram, and provides concrete Redis‑based solutions such as placeholder values, setNX locks, random TTLs, sorted‑set queues, and a Binlog‑Canal‑MQ pipeline.

Cache AvalancheCache ConcurrencyCache Decoupling
0 likes · 7 min read
Five Fatal Cache Pitfalls Explained with Five Diagrams
Cloud Architecture
Cloud Architecture
Jun 27, 2026 · Backend Development

Spring Multi-Level Cache: Production Design & Management with Caffeine + Redis

Spring’s multi‑level caching combines Caffeine’s ultra‑fast local store with Redis’s distributed capacity to tackle high‑concurrency challenges such as read amplification, cache storms, consistency, and capacity management, offering a production‑grade design, implementation details, risk boundaries, and evolution paths for robust Spring applications.

CaffeineMulti-Level CacheRedis
0 likes · 36 min read
Spring Multi-Level Cache: Production Design & Management with Caffeine + Redis
Java Tech Workshop
Java Tech Workshop
Jun 17, 2026 · Backend Development

Step‑by‑Step Source Code Walkthrough of Spring’s Singleton Bean Creation

This article dissects Spring’s singleton bean creation process, explaining the three‑level cache system, the doGetBean and doCreateBean workflows, circular‑dependency handling, proxy generation timing, and common pitfalls such as multithreaded duplicate creation and hot‑deployment cache issues.

Bean LifecycleCircular DependencySpring
0 likes · 11 min read
Step‑by‑Step Source Code Walkthrough of Spring’s Singleton Bean Creation
Programmer XiaoFu
Programmer XiaoFu
Jun 15, 2026 · Backend Development

Why a Simple Redis Mutex Lock Isn’t Enough for Cache Breakdown – When to Use Never‑Expire or Logical Expiration

The article analyzes why a basic Redis mutex lock can cause thread blocking, latency spikes, and service collapse under high concurrency, and compares it with logical expiration and never‑expire with proactive updates, explaining their trade‑offs and how to choose the right cache‑breakdown mitigation strategy.

Logical ExpirationNever ExpireRedis
0 likes · 12 min read
Why a Simple Redis Mutex Lock Isn’t Enough for Cache Breakdown – When to Use Never‑Expire or Logical Expiration
Deepin Linux
Deepin Linux
Jun 9, 2026 · Fundamentals

Why Is CPU Computation Lightning‑Fast While Data Lookup So Slow?

CPU arithmetic runs at near‑physical limits because all operations stay on‑chip, but data lookup is throttled by three physical bottlenecks—storage hierarchy, data placement, and addressing rules—forcing the processor to wait for cache, memory or disk transfers and dramatically reducing overall system throughput.

CPUOptimizationcache
0 likes · 18 min read
Why Is CPU Computation Lightning‑Fast While Data Lookup So Slow?
Architect Chen
Architect Chen
Jun 7, 2026 · Databases

Complete 2026 Guide to Redis Commands: Everything You Need to Know

This article offers a comprehensive 2026 overview of Redis commands, organized by function, with clear usage examples, return values, performance notes, and best‑practice recommendations such as avoiding KEYS in production and using SCAN, making it a practical reference for developers and architects.

DatabaseHashRedis
0 likes · 6 min read
Complete 2026 Guide to Redis Commands: Everything You Need to Know
Raymond Ops
Raymond Ops
Jun 4, 2026 · Operations

Are Buffer and Cache Memory Leaks? Understanding Linux Memory Management

The article explains that Linux’s free command can be misleading, clarifies the roles of Buffer, Cache, and Available memory, shows how to interpret /proc/meminfo, use OOM Killer, manually drop caches, configure cgroup limits, and adopt best‑practice monitoring.

BufferLinuxMemory Management
0 likes · 7 min read
Are Buffer and Cache Memory Leaks? Understanding Linux Memory Management
Java Tech Workshop
Java Tech Workshop
Jun 4, 2026 · Backend Development

Understanding SpringBoot Two‑Level Caching: MyBatis vs Application‑Level Cache

The article explains how layered caching in Java back‑ends—combining MyBatis first‑ and second‑level caches with a service‑layer Caffeine + Redis cache—affects cache granularity, consistency, distribution, and performance, and provides concrete configuration examples, code snippets, and best‑practice guidelines.

CaffeineMyBatisRedis
0 likes · 16 min read
Understanding SpringBoot Two‑Level Caching: MyBatis vs Application‑Level Cache
Architect Chen
Architect Chen
Jun 1, 2026 · Databases

15 Essential Redis Commands Every Engineer Should Know

This article provides a detailed walkthrough of the 15 most commonly used Redis commands—including key, hash, list, set, sorted‑set, and monitoring operations—showing syntax, return values, typical use cases, performance characteristics, and cautions for production environments.

DatabaseMonitoringRedis
0 likes · 6 min read
15 Essential Redis Commands Every Engineer Should Know
Java Tech Workshop
Java Tech Workshop
Jun 1, 2026 · Backend Development

Advanced SpringBoot Caching: How to Build a Custom CacheManager

The article explains why the default SpringBoot cache manager is insufficient for production, then walks through creating custom Caffeine and Redis CacheManager beans, configuring expiration, key prefixes, serialization, and multi‑level caching to solve issues like cache penetration, key collisions, and performance bottlenecks.

CacheManagerCaffeineMulti-Level Cache
0 likes · 11 min read
Advanced SpringBoot Caching: How to Build a Custom CacheManager
Architect Chen
Architect Chen
Apr 29, 2026 · Backend Development

The Ultimate Redis Guide: In‑Depth Overview of Architecture, Data Types, and Advanced Features

This comprehensive Redis guide covers its role as a core component in large‑scale architectures, explains common use cases, walks through installation and configuration options, details all primary data structures with commands and examples, and explores persistence, transactions, Lua scripting, replication, Sentinel, and cluster modes.

ClusterData StructuresLua Scripting
0 likes · 18 min read
The Ultimate Redis Guide: In‑Depth Overview of Architecture, Data Types, and Advanced Features
Code Mala Tang
Code Mala Tang
Apr 25, 2026 · Artificial Intelligence

Why Claude Feels Nerfed Without a Formal Downgrade: A Deep Dive into System‑Level Performance Changes

The article examines the recent Claude performance controversy, showing that engineering adjustments to inference parameters, cache handling, and system prompts rewrote the model’s behavior, making it answer faster but think shallower, leading users to perceive a degradation despite no official model downgrade.

AIClaudeLLM
0 likes · 14 min read
Why Claude Feels Nerfed Without a Formal Downgrade: A Deep Dive into System‑Level Performance Changes
java1234
java1234
Apr 18, 2026 · Backend Development

Beyond Simple Caching: 8 Essential Redis Use Cases for Java Backend Engineers

This guide walks Java backend developers through Redis’s eight core scenarios—caching, distributed locks, rate limiting, session sharing, leaderboards, counters, message and delay queues, bitmap statistics, and geolocation—providing complete code, diagrams, and production‑grade best practices.

BitmapGEOLeaderboard
0 likes · 21 min read
Beyond Simple Caching: 8 Essential Redis Use Cases for Java Backend Engineers
Deepin Linux
Deepin Linux
Apr 12, 2026 · Fundamentals

Why TLB Matters: Unlocking Linux Kernel Performance

This article explains the role of the Translation Lookaside Buffer (TLB) in Linux virtual‑memory translation, covering basic address concepts, page‑table mechanics, TLB operation, flush and synchronization strategies, hardware vs software management, Linux kernel APIs, and a practical C benchmark comparing sequential and random memory accesses.

Operating SystemsTLBVirtual Memory
0 likes · 36 min read
Why TLB Matters: Unlocking Linux Kernel Performance
Java Architect Handbook
Java Architect Handbook
Apr 4, 2026 · Backend Development

16 Powerful Redis Use Cases Every Backend Engineer Should Know

This article presents a comprehensive guide to 16 practical Redis applications—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, queues, lotteries, likes, product tagging, filtering, social graphs, and leaderboards—complete with command examples, code snippets, and visual illustrations to help developers implement these patterns efficiently.

BitmapLeaderboardRedis
0 likes · 11 min read
16 Powerful Redis Use Cases Every Backend Engineer Should Know
Java Tech Workshop
Java Tech Workshop
Apr 3, 2026 · Backend Development

How to Integrate Redis Cache into Spring Boot: Step‑by‑Step Guide

This article explains why Redis is essential for Spring Boot projects, walks through adding dependencies, configuring connection and serialization, demonstrates CRUD operations for all Redis data types, shows @Cacheable usage, and lists common pitfalls with practical solutions.

RedisSpring Bootbackend
0 likes · 26 min read
How to Integrate Redis Cache into Spring Boot: Step‑by‑Step Guide
Architecture Digest
Architecture Digest
Apr 3, 2026 · Databases

16 Powerful Ways to Leverage Redis in Your Applications

This article presents a comprehensive guide to 16 practical Redis use cases—including caching, distributed locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow‑recommendation models, and ranking—complete with code snippets and data‑structure examples.

Data StructuresDatabaseLeaderboard
0 likes · 10 min read
16 Powerful Ways to Leverage Redis in Your Applications
Tech Musings
Tech Musings
Apr 3, 2026 · Operations

How to Cut Rust Docker Build Times from Minutes to Seconds with Cargo‑Chef

This article analyzes why Docker builds of Rust projects on Ubuntu get stuck updating the crates.io index for several minutes, explains Docker layer cache invalidation and BuildKit differences, and presents a reliable cargo‑chef based Dockerfile that reduces build time to seconds.

Build OptimizationDockerRust
0 likes · 10 min read
How to Cut Rust Docker Build Times from Minutes to Seconds with Cargo‑Chef
Ray's Galactic Tech
Ray's Galactic Tech
Mar 25, 2026 · Backend Development

Mastering Ristretto: High‑Performance Go Cache from Theory to Production

This guide provides an in‑depth, architect‑level walkthrough of Ristretto, the high‑throughput Go cache, covering TinyLFU fundamentals, internal components, parameter tuning, production‑grade wrappers, multi‑level cache design, monitoring, capacity planning, common pitfalls, and real‑world code examples for robust deployment.

DistributedSystemsGoRistretto
0 likes · 29 min read
Mastering Ristretto: High‑Performance Go Cache from Theory to Production
Architect's Guide
Architect's Guide
Mar 19, 2026 · Backend Development

Boost API Speed 10× with a Three‑Level Cache Pyramid in Spring Boot 3

This article explains why adding Redis alone may still be slow, introduces a three‑level cache pyramid (Caffeine L1, Redis L2, DB L3) built with Spring Boot 3, and provides complete configuration, code, warm‑up, monitoring, and benchmark results that reduce response time from 28 ms to 2 ms while cutting CPU usage by 35%.

CaffeineRedisSpring Boot
0 likes · 9 min read
Boost API Speed 10× with a Three‑Level Cache Pyramid in Spring Boot 3
Woodpecker Software Testing
Woodpecker Software Testing
Feb 28, 2026 · Operations

Boost Large Language Model Testing Performance: Essential Strategies for Test Engineers

The article outlines four engineering‑driven approaches—layered test granularity, cache‑driven golden sample pools, lightweight evaluation proxies, and test‑as‑code with resource‑aware scheduling—to dramatically cut LLM testing latency, improve reliability, and lower costs, illustrated with real‑world banking, government, and medical case studies.

CI/CDEvaluation ProxyLarge Language Models
0 likes · 8 min read
Boost Large Language Model Testing Performance: Essential Strategies for Test Engineers
Coder Trainee
Coder Trainee
Feb 17, 2026 · Backend Development

How @CachePut Updates Cache in Spring Cache

The article explains that @CachePut serves as a trigger to update or add cache entries in Spring Cache, contrasting its behavior with @Cacheable, detailing execution flow, handling of null results, and the recommendation against using both annotations on the same method.

CachePutCacheableSpring
0 likes · 3 min read
How @CachePut Updates Cache in Spring Cache
Coder Trainee
Coder Trainee
Feb 14, 2026 · Backend Development

Using RedisTemplate to Manage String and Hash Data in Spring

This article demonstrates how to encapsulate common RedisTemplate operations—such as deleting single or multiple keys, setting expiration, checking existence, and performing String and Hash CRUD actions—by providing concrete Java code examples and step‑by‑step method implementations.

HashRedisRedisTemplate
0 likes · 4 min read
Using RedisTemplate to Manage String and Hash Data in Spring
java1234
java1234
Feb 3, 2026 · Backend Development

Boost API Latency 10× with Spring Boot 3 and a Local Cache Pyramid

The article demonstrates how to achieve a ten‑fold reduction in API response time by building a three‑level cache pyramid (Caffeine L1, Redis L2, DB L3) in Spring Boot 3, covering dependencies, configuration, core template code, warm‑up, monitoring, load‑test results and common high‑concurrency pitfalls.

CaffeineMonitoringRedis
0 likes · 8 min read
Boost API Latency 10× with Spring Boot 3 and a Local Cache Pyramid
Code Wrench
Code Wrench
Jan 21, 2026 · Backend Development

Mastering Cache Eviction in Go: When and How to Use LRU

This article explains why naive cache eviction fails, why LRU is the go‑to strategy for many Go projects, and provides a production‑ready LRU implementation with detailed code, lock‑granularity tips, key design considerations, and scenarios where LRU is not suitable.

GoLRUcache
0 likes · 9 min read
Mastering Cache Eviction in Go: When and How to Use LRU
Xiaohongshu Tech REDtech
Xiaohongshu Tech REDtech
Jan 19, 2026 · Databases

How Merged Seckill Boosts MySQL Write Throughput 5× for High‑Traffic E‑Commerce

The article details a MySQL kernel‑level merged‑seckill optimization that replaces traditional queue‑based flash‑sale handling, achieving up to 5.5× higher TPS (up to 23,543 TPS on 128 threads) and sustaining 1.5W+ orders per second, while remaining transparent to applications and preserving compatibility with existing SQL.

DatabaseLockMySQL
0 likes · 11 min read
How Merged Seckill Boosts MySQL Write Throughput 5× for High‑Traffic E‑Commerce
Java Architect Handbook
Java Architect Handbook
Jan 10, 2026 · Backend Development

Boost API Speed 14× with a 3‑Level Cache Pyramid in Spring Boot

By combining a local Caffeine cache, a remote Redis layer, and a MySQL database into a three‑tier cache pyramid, this guide shows how to reduce API response time from 28 ms to 2 ms, cut CPU usage by 35 %, and achieve up to 14‑fold performance gains, complete with configuration, code, and monitoring tips.

CaffeineRedisSpring Boot
0 likes · 12 min read
Boost API Speed 14× with a 3‑Level Cache Pyramid in Spring Boot
java1234
java1234
Jan 6, 2026 · Backend Development

Boost API Latency 10× with Spring Boot 3 and a Three‑Level Local Cache Pyramid

The article explains why adding Redis alone often remains slow, introduces a three‑level cache pyramid (L1 Caffeine, L2 Redis, L3 MySQL) built with Spring Boot 3, and shows how this design reduces request latency from 28 ms to 2 ms, cuts CPU usage by 35 % and achieves up to 14‑fold throughput improvement.

CaffeineRedisSpring Boot
0 likes · 10 min read
Boost API Latency 10× with Spring Boot 3 and a Three‑Level Local Cache Pyramid
Java Companion
Java Companion
Jan 4, 2026 · Backend Development

Achieve 10× Faster APIs with Spring Boot 3’s Three‑Level Cache Pyramid

The article demonstrates how to combine Spring Boot 3, Caffeine local cache, and Redis into a three‑level cache pyramid, reducing API response time from 28 ms to 2 ms, cutting CPU usage by 35 %, and providing detailed configuration, code examples, performance benchmarks, and mitigation strategies for common high‑concurrency pitfalls.

CaffeineRedisSpring Boot
0 likes · 10 min read
Achieve 10× Faster APIs with Spring Boot 3’s Three‑Level Cache Pyramid
Su San Talks Tech
Su San Talks Tech
Dec 9, 2025 · Backend Development

Choosing the Right Local Cache: From ConcurrentHashMap to Caffeine

This article explains why local caches are essential in high‑performance services, outlines required cache features, compares four Java‑based local cache implementations (ConcurrentHashMap, Guava Cache, Caffeine, Ehcache), and offers practical solutions for consistency, hit‑rate improvement, and technology selection.

CaffeineEhcacheGuava
0 likes · 12 min read
Choosing the Right Local Cache: From ConcurrentHashMap to Caffeine
IT Services Circle
IT Services Circle
Dec 8, 2025 · Fundamentals

How DNS Translates Domain Names to IPs and Keeps Your Browsing Lightning‑Fast

This article explains how the Domain Name System (DNS) converts human‑readable website names into IP addresses, details the four‑layer caching hierarchy, compares recursive and iterative query modes, outlines common DNS failures, and provides practical steps to troubleshoot and accelerate DNS resolution.

DNSDomain Name SystemNetworking
0 likes · 16 min read
How DNS Translates Domain Names to IPs and Keeps Your Browsing Lightning‑Fast
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 24, 2025 · Backend Development

How to Prevent Cache Penetration in High‑Concurrency Systems

The article explains what cache penetration is in high‑concurrency architectures, why it occurs, and presents four practical mitigation strategies—including caching empty values, using Bloom filters, validating request data, and applying rate‑limiting—to protect backend databases from overload.

Bloom filterCache Penetrationcache
0 likes · 6 min read
How to Prevent Cache Penetration in High‑Concurrency Systems
DeWu Technology
DeWu Technology
Nov 19, 2025 · Databases

How Our Self‑Built Redis Evolved: Architecture, SDK, and Performance Gains

This article details the three‑year evolution of a self‑built Redis service, covering its massive scale, architectural redesign, migration from LB to a custom DRedis SDK, same‑city active‑active near‑read support, Redis‑server version upgrades, instance specifications, proxy rate‑limiting, and extensive automation that together boost performance while cutting costs.

AutomationDatabaseRedis
0 likes · 17 min read
How Our Self‑Built Redis Evolved: Architecture, SDK, and Performance Gains
Code Wrench
Code Wrench
Nov 18, 2025 · Cloud Native

How Kubernetes Informers Power Real‑Time, Low‑Cost Cluster Event Handling

This article explains why Kubernetes relies on Informers—detailing their internal components, how they transform massive API Server events into efficient local caches, and providing step‑by‑step Go code examples that reveal the architecture behind Kubernetes' high‑throughput, event‑driven design.

ControllerGoInformer
0 likes · 8 min read
How Kubernetes Informers Power Real‑Time, Low‑Cost Cluster Event Handling
Ray's Galactic Tech
Ray's Galactic Tech
Nov 9, 2025 · Databases

Mastering Redis Expiration: Strategies, Java Implementation, and Best Practices

Redis uses multiple expiration and eviction mechanisms—including lazy deletion, periodic scanning, and memory eviction—to balance performance and memory usage, and this guide explains each strategy, shows how to configure them, and provides Java/Jedis code examples for setting TTLs, handling large objects, preventing cache avalanches, and monitoring stats.

RedisTTLcache
0 likes · 7 min read
Mastering Redis Expiration: Strategies, Java Implementation, and Best Practices
Java Backend Technology
Java Backend Technology
Nov 4, 2025 · Backend Development

10 Essential Spring Boot Features Every Developer Should Master

This comprehensive guide explores the most powerful Spring Boot capabilities—including @Conditional, @ConfigurationProperties, Actuator, DevTools, Retry, Cache, testing strategies, custom starters, Admin, and CLI—providing code examples and deep analysis to help developers boost productivity, reliability, and maintainability of their applications.

@ConditionalActuatorConfigurationProperties
0 likes · 20 min read
10 Essential Spring Boot Features Every Developer Should Master
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 2, 2025 · Backend Development

How to Stop Cache Penetration: 4 Proven Strategies for Robust Backends

This article explains what cache penetration is, why it occurs when requests bypass the cache to hit the database, and presents four effective mitigation techniques—including empty-result caching, Bloom filters, request validation, and distributed rate limiting—to safeguard backend performance.

Backend PerformanceBloom filterCache Penetration
0 likes · 4 min read
How to Stop Cache Penetration: 4 Proven Strategies for Robust Backends
JD Cloud Developers
JD Cloud Developers
Oct 30, 2025 · Backend Development

How a Massive Cache Key Crashed a Double‑11 System and How to Prevent It

During a Double‑11 promotion, an oversized Redis cache key caused a cascade of failures—cache miss, network bandwidth saturation, and a full‑blown cache avalanche—prompting the team to implement big‑key mitigation, compression, lock‑based cache back‑source, and monitoring measures to safeguard future deployments.

Big KeyHot KeyRedis
0 likes · 8 min read
How a Massive Cache Key Crashed a Double‑11 System and How to Prevent It
Ray's Galactic Tech
Ray's Galactic Tech
Oct 17, 2025 · Backend Development

Prevent Redis Cache Avalanche, Penetration & Breakdown: A Practical High‑Availability Guide

This guide explains the three major Redis cache failure patterns—avalanche, penetration, and breakdown—detailing their causes and offering concrete mitigation techniques such as staggered TTLs, empty‑object caching, Bloom filters, logical expiration, distributed locks, high‑availability clusters, and comprehensive monitoring to ensure robust high‑availability systems.

Cache AvalancheCache BreakdownCache Penetration
0 likes · 7 min read
Prevent Redis Cache Avalanche, Penetration & Breakdown: A Practical High‑Availability Guide
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 14, 2025 · Backend Development

5 Common Redis Cache Anti‑Patterns and How to Fix Them

This article examines five frequent Redis cache anti‑patterns—cache avalanche, unbounded local cache, stale data, missing invalidation, and oversized objects—explaining their pitfalls with code examples and showing concrete fixes that dramatically improve latency, throughput, and memory usage.

Anti-PatternCaffeineRedis
0 likes · 15 min read
5 Common Redis Cache Anti‑Patterns and How to Fix Them
JD Retail Technology
JD Retail Technology
Sep 4, 2025 · Operations

Mastering High Availability: Real-World Pitfalls and Solutions from JD's Production Systems

This article walks through the challenges of building high‑availability systems—covering applications, databases, caches, message queues, containers, GC, and more—using JD’s production experiences to highlight common pitfalls, root‑cause analyses, and practical mitigation strategies for engineers seeking resilient architecture.

Fault ToleranceHigh AvailabilityJDK
0 likes · 37 min read
Mastering High Availability: Real-World Pitfalls and Solutions from JD's Production Systems
JakartaEE China Community
JakartaEE China Community
Sep 2, 2025 · Backend Development

Choosing the Right Cache Solution: Key Criteria and Trade‑offs

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.

JCacheSpring CacheTTL
0 likes · 12 min read
Choosing the Right Cache Solution: Key Criteria and Trade‑offs
MaGe Linux Operations
MaGe Linux Operations
Aug 18, 2025 · Operations

Redis Cache Pitfalls: Penetration, Avalanche, Breakdown – Solutions & Real Cases

This article examines the three classic Redis caching problems—cache penetration, cache avalanche, and cache breakdown—illustrates real‑world incidents that caused system outages, and provides comprehensive mitigation techniques such as Bloom filters, null‑value caching, random expiration, multi‑level caches, logical expiration, and distributed locks, along with monitoring and disaster‑recovery practices.

PythonRediscache
0 likes · 25 min read
Redis Cache Pitfalls: Penetration, Avalanche, Breakdown – Solutions & Real Cases
Sanyou's Java Diary
Sanyou's Java Diary
Aug 7, 2025 · Backend Development

How Easy-Cache Solves Distributed Cache Pain Points with Multi-Level Design

This article introduces Easy-Cache, a Spring-AOP based caching framework that provides annotation-driven, multi-level Redis and local cache with dynamic upgrade/downgrade, elastic expiration, and Lua-script-ensured data consistency, eliminating repetitive cache code and handling failures, cache penetration, breakdown, and eventual consistency challenges.

LuaMulti-Level CacheSpring AOP
0 likes · 18 min read
How Easy-Cache Solves Distributed Cache Pain Points with Multi-Level Design
Tech Freedom Circle
Tech Freedom Circle
Aug 5, 2025 · Backend Development

How to Diagnose and Fix Sudden Redis Slowdowns: A Complete Five‑Step Guide

This article provides a systematic, step‑by‑step methodology for identifying the root causes of Redis performance degradation—including big keys, slow queries, expiration spikes, memory limits, fork latency, AOF flushing, memory fragmentation, swap usage, huge pages, and CPU binding—and offers immediate mitigation tactics as well as long‑term architectural solutions to restore and maintain high throughput.

MemoryRedisbackend
0 likes · 50 min read
How to Diagnose and Fix Sudden Redis Slowdowns: A Complete Five‑Step Guide
Programmer XiaoFu
Programmer XiaoFu
Jul 22, 2025 · Backend Development

Mastering Cache Penetration, Avalanche, and Breakdown: Interview-Ready Answers

The article explains the concepts of cache penetration, avalanche, and breakdown, outlines their typical causes such as invalid requests, synchronized expirations, and hotspot spikes, and presents practical mitigation techniques including request validation, caching null values, Bloom filters, staggered expirations, high‑availability Redis setups, mutex locks, and random TTLs.

Bloom filterCache AvalancheCache Breakdown
0 likes · 8 min read
Mastering Cache Penetration, Avalanche, and Breakdown: Interview-Ready Answers
Deepin Linux
Deepin Linux
Jul 21, 2025 · Fundamentals

Unlocking CPU Speed: How Cache Bridges the Gap Between Processor and Memory

This article explains why modern CPUs need cache memory, describes the hierarchy of L1‑L3 caches, the principles of locality, write policies, multi‑core coherence mechanisms such as bus snooping and the MESI protocol, and offers practical code‑level optimizations to improve cache performance.

CPUMESI Protocolcache
0 likes · 31 min read
Unlocking CPU Speed: How Cache Bridges the Gap Between Processor and Memory
Cognitive Technology Team
Cognitive Technology Team
Jul 20, 2025 · Fundamentals

How False Sharing Slows Java Programs and How to Eliminate It

This article explains what false sharing is in Java, how cache lines and cache‑line invalidation cause performance penalties, and provides concrete code examples and @Contended annotation techniques to detect and fix false sharing for faster multithreaded applications.

Contendedcacheconcurrency
0 likes · 10 min read
How False Sharing Slows Java Programs and How to Eliminate It
Deepin Linux
Deepin Linux
Jul 15, 2025 · Fundamentals

Mastering LRU Cache: Theory, C++ Implementation, and Interview Strategies

This article explains the core principles of the Least Recently Used (LRU) cache algorithm, details its operation and complexity, provides a complete C++ implementation with line-by-line analysis, showcases test cases, and offers practical interview tips and extensions such as LFU and LRU‑K.

AlgorithmC++Interview
0 likes · 18 min read
Mastering LRU Cache: Theory, C++ Implementation, and Interview Strategies
Code Mala Tang
Code Mala Tang
Jul 12, 2025 · Frontend Development

Master Data Fetching in React with TanStack Query: From Simple Queries to Optimistic Updates

This guide walks you through using TanStack Query in React, covering simple queries, custom hooks, selectors, dependent queries, pagination, infinite scrolling, query key factories, mutations, query invalidation, conditional fetching, optimistic updates, and global error handling with Suspense, all illustrated with clear code examples.

Data FetchingOptimistic UpdateReAct
0 likes · 7 min read
Master Data Fetching in React with TanStack Query: From Simple Queries to Optimistic Updates
Deepin Linux
Deepin Linux
Jul 10, 2025 · Fundamentals

Mastering LRUCache: How to Build a High‑Performance Cache in C++

Explore the principles behind Least Recently Used (LRU) caching, understand why it outperforms FIFO and LFU strategies, and follow a step‑by‑step C++ implementation using hash tables and doubly linked lists, complete with detailed code, testing, and performance optimization tips.

C++Data StructureLRUCache
0 likes · 24 min read
Mastering LRUCache: How to Build a High‑Performance Cache in C++
JD Cloud Developers
JD Cloud Developers
Jun 30, 2025 · Backend Development

Unveiling Guava Cache Internals: Why It Lags Behind Caffeine

This article dissects Guava Cache's source code, explaining its segment‑based locking, data structures, put/get implementations, cleanup and eviction mechanisms, and then contrasts its performance and design choices with the more modern Caffeine cache, highlighting why Guava falls short.

CaffeineGuavaSegment
0 likes · 39 min read
Unveiling Guava Cache Internals: Why It Lags Behind Caffeine
Deepin Linux
Deepin Linux
Jun 26, 2025 · Fundamentals

How Memory I/O Powers Your Computer: From CPU to Cache Explained

This article demystifies memory I/O by exploring its hardware foundations, the interaction between CPU and memory controllers, the role of user and kernel spaces, timing parameters, cache hierarchies, and practical optimization strategies for databases, file systems, and server applications.

CPUOptimizationSystem Call
0 likes · 33 min read
How Memory I/O Powers Your Computer: From CPU to Cache Explained
Linux Kernel Journey
Linux Kernel Journey
Jun 17, 2025 · Fundamentals

Master the Three Classic Cache Mapping Strategies: Theory and Practical Implementation

This article explains why cache is critical for computer performance and provides a thorough analysis of the three classic cache mapping strategies—direct‑mapped, fully associative, and set‑associative—detailing their mechanisms, advantages, disadvantages, concrete examples, and guidance on selecting the appropriate method for different system scenarios.

Direct MappingFully AssociativeSet Associative
0 likes · 24 min read
Master the Three Classic Cache Mapping Strategies: Theory and Practical Implementation
Deepin Linux
Deepin Linux
Jun 16, 2025 · Fundamentals

Understanding Cache Mapping: Direct, Fully‑Associative, and Set‑Associative Explained

This article explores the role of cache in computer systems and provides a detailed comparison of the three main cache mapping techniques—direct mapping, fully associative mapping, and set‑associative mapping—covering their mechanisms, advantages, disadvantages, and practical selection guidelines.

Direct MappingFully AssociativeSet Associative
0 likes · 23 min read
Understanding Cache Mapping: Direct, Fully‑Associative, and Set‑Associative Explained
Cognitive Technology Team
Cognitive Technology Team
May 14, 2025 · Backend Development

Cache and Database Consistency: Strategies for Updating Order

This article examines common cache‑database consistency challenges and compares four update strategies—including write‑through, cache‑aside, and delayed double‑delete—to help backend developers choose the most suitable approach for maintaining data integrity in high‑traffic systems.

Cache AsideData synchronizationcache
0 likes · 6 min read
Cache and Database Consistency: Strategies for Updating Order
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 10, 2025 · Backend Development

7 Advanced Spring Boot Cases: Resilience4j, Actuator, Cache & More

This article presents seven advanced Spring Boot topics—including Resilience4j circuit breaking, custom Actuator health checks, Saga-based distributed transactions, cache optimization, asynchronous processing, Gateway vs. Zuul, and OAuth2/JWT security—each illustrated with concise explanations, implementation steps, and code samples.

ActuatorGatewayOAuth2
0 likes · 11 min read
7 Advanced Spring Boot Cases: Resilience4j, Actuator, Cache & More
JD Cloud Developers
JD Cloud Developers
Apr 16, 2025 · Backend Development

Master Spring Cache Annotations: @EnableCaching, @Cacheable, @CachePut, @CacheEvict Explained

This article explains how Spring's caching annotations—@EnableCaching, @Cacheable, @CachePut, and @CacheEvict—work together to simplify cache management, includes Maven dependency setup, configuration class, entity and service code, a full Spring Boot example, test cases, and visual illustrations of cache miss, hit, update, and eviction.

RedisSpringannotations
0 likes · 13 min read
Master Spring Cache Annotations: @EnableCaching, @Cacheable, @CachePut, @CacheEvict Explained
Raymond Ops
Raymond Ops
Apr 4, 2025 · Databases

Mastering Redis: Persistence, Cache Pitfalls, Data Types, Clustering & Locks

This article explains Redis persistence mechanisms (RDB and AOF), common cache problems and their solutions, the various Redis data structures and their use cases, cluster deployment options, master‑slave replication, transaction commands, and how to implement distributed locks with SETNX and expiration.

ClusteringData TypesPersistence
0 likes · 13 min read
Mastering Redis: Persistence, Cache Pitfalls, Data Types, Clustering & Locks