BestHub
Sign in
Tagged articles
3240 articles
Page 22 of 33
Tencent Cloud Developer
Tencent Cloud Developer
Jul 27, 2021 · Backend Development

Comprehensive Guide to Go Unit Testing: Tools, Mocking, and Dependency Management

This guide explains Go’s built‑in testing framework, assertion libraries, table‑driven and sub‑tests, and demonstrates how to mock functions, structs, interfaces, databases, and Redis using tools such as ngmock, gomock, sqlmock and miniredis, while covering test setup, teardown, coverage handling, and best‑practice insights.

GoMockSQLite
0 likes · 21 min read
Comprehensive Guide to Go Unit Testing: Tools, Mocking, and Dependency Management
dbaplus Community
dbaplus Community
Jul 25, 2021 · Backend Development

Is Redis Distributed Lock Safe? Deep Dive into Redlock and Zookeeper Pitfalls

This article thoroughly explains why distributed locks are needed, walks through basic Redis lock implementations, exposes deadlock and expiration issues, presents robust solutions with unique IDs and Lua scripts, examines the Redlock algorithm, reviews the Martin‑Antirez debate, and compares Redis with Zookeeper locks.

LuaRedlockZooKeeper
0 likes · 40 min read
Is Redis Distributed Lock Safe? Deep Dive into Redlock and Zookeeper Pitfalls
Laravel Tech Community
Laravel Tech Community
Jul 23, 2021 · Backend Development

Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Mitigation Strategies

The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis‑based systems, describes the performance risks they pose to persistent databases, and presents practical mitigation techniques such as Bloom filters, empty‑object caching, hot‑key permanence, distributed locks, high‑availability clusters, rate limiting, and data pre‑warming.

BackendCachebloom-filter
0 likes · 6 min read
Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Mitigation Strategies
Programmer DD
Programmer DD
Jul 22, 2021 · Backend Development

How to Achieve Exactly‑Once Message Processing in RocketMQ Without Heavy Transactions

This article explains why message middleware guarantees at‑least‑once delivery, the challenges of duplicate consumption, and presents both simple and advanced deduplication strategies—including transactional and non‑transactional approaches using relational databases or Redis—to achieve effectively exactly‑once semantics in RocketMQ.

Exactly-OnceIdempotenceMessage Deduplication
0 likes · 18 min read
How to Achieve Exactly‑Once Message Processing in RocketMQ Without Heavy Transactions
vivo Internet Technology
vivo Internet Technology
Jul 21, 2021 · Backend Development

Resolving Duplicate OpenID Insertions in Fast App Center: Analysis and Distributed Lock Solutions

The Fast App Center’s duplicate OpenID rows were traced to a non‑atomic check‑then‑insert race condition, prompting the team to evaluate a unique‑index safeguard versus application‑level distributed locking, ultimately implementing a Redis‑based lock to serialize inserts and adding a cleanup job to purge existing duplicates.

Database Concurrencybackend-developmentdistributed-lock
0 likes · 18 min read
Resolving Duplicate OpenID Insertions in Fast App Center: Analysis and Distributed Lock Solutions
Wukong Talks Architecture
Wukong Talks Architecture
Jul 21, 2021 · Fundamentals

Understanding Redis Simple Dynamic Strings (SDS): Structure, Benefits, and Memory Management

This article explains the Redis Simple Dynamic String (SDS) data structure, comparing it with traditional C strings, detailing its struct layout, O(1) length retrieval, pre‑allocation strategy, lazy space release, and provides code examples illustrating how SDS avoids buffer overflows and improves performance.

C stringsData StructuresMemory Management
0 likes · 11 min read
Understanding Redis Simple Dynamic Strings (SDS): Structure, Benefits, and Memory Management
Efficient Ops
Efficient Ops
Jul 20, 2021 · Databases

Master Redis: 13 Proven Practices to Boost Memory, Performance & Reliability

Discover a comprehensive Redis best‑practice guide covering memory optimization, performance tuning, high reliability, daily operations, resource planning, monitoring, and security, with actionable tips such as key length control, maxmemory settings, lazy‑free, connection pooling, replication strategies, and safe deployment practices.

Database ManagementOperationsperformance optimization
0 likes · 23 min read
Master Redis: 13 Proven Practices to Boost Memory, Performance & Reliability
Architect
Architect
Jul 20, 2021 · Databases

Redis New Features and Architecture Options Overview

This article reviews Redis 6.0 and 5.0 new features, compares deployment architectures such as cluster, master-replica, and read-write split, and provides Java connection-pool code examples to help engineers select the appropriate Redis setup for performance, reliability, and scalability requirements.

ClusterDatabase ArchitectureJedis
0 likes · 11 min read
Redis New Features and Architecture Options Overview
Selected Java Interview Questions
Selected Java Interview Questions
Jul 20, 2021 · Backend Development

Session Sharing Solutions for Distributed Systems: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie Approaches

In distributed micro‑service environments, session sharing is essential to prevent repeated logins, and this article explains four practical solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based centralized sessions, and cookie‑based sharing—detailing their implementations, advantages, and drawbacks.

NginxTomcatredis
0 likes · 5 min read
Session Sharing Solutions for Distributed Systems: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie Approaches
Java Interview Crash Guide
Java Interview Crash Guide
Jul 20, 2021 · Backend Development

Designing a Universal Cache Strategy for Static Data in Microservices

This article outlines a universal caching strategy for low‑frequency static data in microservice systems, explaining why in‑memory caches like Redis are needed, detailing a six‑component architecture with services, queues, and consistency checks, and weighing trade‑offs such as cache eviction, persistence, and scalability.

MicroservicesQueuecaching
0 likes · 15 min read
Designing a Universal Cache Strategy for Static Data in Microservices
Programmer DD
Programmer DD
Jul 19, 2021 · Backend Development

How Redis Ziplist Compresses Memory and When to Use It

This article explains Redis's ziplist compressed list structure, its internal fields, lookup algorithm, performance characteristics, configuration thresholds for Hash and List types, and demonstrates a real‑world use case with memory‑saving calculations and experimental results.

Data Structuresmemory compressionredis
0 likes · 11 min read
How Redis Ziplist Compresses Memory and When to Use It
Top Architect
Top Architect
Jul 18, 2021 · Backend Development

Implementing Distributed Locks with Redis and Redisson in Java

The article explains why Java's synchronized lock cannot be used for distributed scenarios, demonstrates how to build a Redis‑based distributed lock with setIfAbsent, discusses pitfalls such as server crashes and lock expiration, and presents robust solutions including atomic expiration, thread‑ID verification, lock renewal, and Redisson usage.

concurrencyjavaredis
0 likes · 6 min read
Implementing Distributed Locks with Redis and Redisson in Java
Top Architect
Top Architect
Jul 14, 2021 · Databases

Redis Read‑Write Separation Architecture: Star vs. Chain Replication

This article explains Alibaba Cloud's Redis read‑write separation architecture, comparing star and chain replication models, their performance and scalability trade‑offs, and how transparent compatibility, high availability, and high performance are achieved through redis‑proxy, HA monitoring, and optimized binlog replication.

Read-Write Separationdatabaseshigh availability
0 likes · 8 min read
Redis Read‑Write Separation Architecture: Star vs. Chain Replication
Su San Talks Tech
Su San Talks Tech
Jul 14, 2021 · Databases

Why Is Redis So Fast? Deep Dive into Its Core Architecture and Performance

Redis achieves its remarkable speed through a combination of in‑memory data storage, optimized data structures like SDS, ziplist, quicklist and skiplist, a single‑threaded command model, efficient I/O multiplexing, and sophisticated persistence, replication, Sentinel and Cluster mechanisms that together ensure high performance and reliability.

ClusterIn-Memory DatabasePersistence
0 likes · 25 min read
Why Is Redis So Fast? Deep Dive into Its Core Architecture and Performance
Programmer DD
Programmer DD
Jul 12, 2021 · Backend Development

How to Scale Redis for Billions of Keys: Memory‑Saving Strategies

This article examines the challenges of storing massive DMP data in Redis, analyzes memory fragmentation, key‑value explosion, and latency constraints, and presents practical solutions such as eviction policies, bucket hashing, key compression, and fragmentation reduction to enable efficient in‑memory storage.

javalarge-scale storageredis
0 likes · 11 min read
How to Scale Redis for Billions of Keys: Memory‑Saving Strategies
Su San Talks Tech
Su San Talks Tech
Jul 12, 2021 · Backend Development

Master Redisson: Simplify Distributed Locks in Spring Boot

This tutorial explains how to integrate Redisson into a Spring Boot application to implement robust distributed locks, covering Redisson's architecture, configuration, code examples, lock types, watchdog mechanism, and practical testing procedures for reentrant, read‑write, and semaphore locks.

Spring Bootredisredisson
0 likes · 13 min read
Master Redisson: Simplify Distributed Locks in Spring Boot
Top Architect
Top Architect
Jul 10, 2021 · Backend Development

Optimizing Complex Search Queries with Redis: A Backend Development Demo

This article explores how backend developers can handle intricate e‑commerce search filters by first attempting a monolithic SQL solution, then improving performance with index analysis and query splitting, and finally achieving fast, scalable results using Redis sets, sorted sets, and transaction commands.

backend-developmentcachingperformance
0 likes · 8 min read
Optimizing Complex Search Queries with Redis: A Backend Development Demo
Selected Java Interview Questions
Selected Java Interview Questions
Jul 9, 2021 · Backend Development

Various Strategies for Deploying Distributed Scheduled Tasks on a Single Server

The article compares five practical methods—single‑server deployment, IP‑based restriction, database‑driven task selection, Redis expiration with distributed lock, and Quartz clustering—to ensure that a scheduled job runs only once across multiple servers, outlining each approach's advantages, drawbacks, and implementation details.

Quartzmysqlredis
0 likes · 5 min read
Various Strategies for Deploying Distributed Scheduled Tasks on a Single Server
Architect
Architect
Jul 9, 2021 · Backend Development

Designing a High‑Concurrency Flash Sale System: Architecture, Caching, Rate Limiting, and Isolation Strategies

This article explains how to design a flash‑sale (秒杀) system that can handle massive traffic spikes by using static page CDN caching, gateway request interception, Redis inventory control, asynchronous order processing, and thorough business, deployment, and data isolation to ensure high performance and stability without affecting regular services.

CDNSystem Architecturebackend design
0 likes · 10 min read
Designing a High‑Concurrency Flash Sale System: Architecture, Caching, Rate Limiting, and Isolation Strategies
Beike Product & Technology
Beike Product & Technology
Jul 8, 2021 · Fundamentals

Understanding HyperLogLog: Algorithm Principles, Redis Implementation, and Experimental Analysis

This article explores the HyperLogLog algorithm for cardinality estimation, tracing its development from Linear and LogLog counting, detailing its Redis implementation with sparse and dense encodings and command workflows, and presenting experiments that demonstrate its memory efficiency and analyze observed error rates versus the theoretical 0.81% standard deviation.

HyperLogLogalgorithmcardinality estimation
0 likes · 13 min read
Understanding HyperLogLog: Algorithm Principles, Redis Implementation, and Experimental Analysis
Sohu Tech Products
Sohu Tech Products
Jul 7, 2021 · Backend Development

Implementing Nearby‑People (LBS) with MySQL and Redis GEO

This article explains how to build a location‑based "nearby people" feature by storing coordinates in MySQL, filtering with rectangular bounds, calculating distances in Java, and then scaling the solution with Redis GEO using GeoHash and Sorted Sets for high‑performance proximity queries.

GeoHashLBSLocation Services
0 likes · 14 min read
Implementing Nearby‑People (LBS) with MySQL and Redis GEO
vivo Internet Technology
vivo Internet Technology
Jul 7, 2021 · Databases

Lettuce vs Jedis: Features, Usage, and Comparison of Java Redis Clients

Lettuce, a thread‑safe, Netty‑based Java Redis client supporting synchronous, asynchronous, reactive, Cluster, Sentinel, pipelining and custom codecs, outperforms Jedis’s non‑thread‑safe pooled connections by reducing resource consumption, simplifying Spring integration, and offering advanced features like read‑write splitting, topology refresh, and optional pooling for high‑throughput applications.

AsyncConnection PoolJedis
0 likes · 15 min read
Lettuce vs Jedis: Features, Usage, and Comparison of Java Redis Clients
Selected Java Interview Questions
Selected Java Interview Questions
Jul 7, 2021 · Operations

Redis Monitoring Metrics and Commands Guide

This article provides a comprehensive overview of Redis monitoring metrics—including performance, memory, basic activity, persistence, and error indicators—along with recommended monitoring tools, configuration settings, and command-line examples for gathering and interpreting these metrics in production environments.

MetricsOperationsdatabase
0 likes · 7 min read
Redis Monitoring Metrics and Commands Guide
macrozheng
macrozheng
Jul 5, 2021 · Backend Development

Master Spring Cache: Simplify Caching Across Redis, Ehcache, and More

This article introduces Spring Cache as a unified caching solution that abstracts away the specifics of Redis, Ehcache, and other providers, explains its core concepts, annotations, configuration, and demonstrates practical usage with code examples to eliminate manual cache handling.

EhcacheSpring BootSpring Cache
0 likes · 16 min read
Master Spring Cache: Simplify Caching Across Redis, Ehcache, and More
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 3, 2021 · Backend Development

Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster

The article explains how to abstract remote data location logic using an RPC framework built on Spring and Dubbo, demonstrates proxy injection and service registration, and shows how similar principles are applied to Redis Cluster to reduce request redirection and improve scalability.

Distributed Systemsbackend-developmentjava
0 likes · 12 min read
Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster
IT Architects Alliance
IT Architects Alliance
Jul 1, 2021 · Backend Development

How to Build a High‑Performance Flash‑Sale System with Redis Caching and CDN

This article explains the challenges of flash‑sale traffic spikes and presents a multi‑layered backend architecture—using CDN‑cached static pages, read‑write split Redis, Lua scripts for atomic stock deduction, and Redis‑based message queues—to achieve high concurrency, stability, and fairness.

Backend ArchitectureCDNLua scripting
0 likes · 9 min read
How to Build a High‑Performance Flash‑Sale System with Redis Caching and CDN
Java Interview Crash Guide
Java Interview Crash Guide
Jul 1, 2021 · Backend Development

How to Store Billions of IDs in Redis Efficiently: Strategies for Massive DMP Caches

This article examines the challenges of storing and querying billions of DMP identifiers in Redis, analyzes data characteristics and memory fragmentation issues, and presents practical solutions such as eviction policies, bucket‑based key hashing, and fragmentation reduction techniques to achieve low‑latency, large‑scale caching.

DMPKey hashingjava
0 likes · 11 min read
How to Store Billions of IDs in Redis Efficiently: Strategies for Massive DMP Caches
ITPUB
ITPUB
Jun 30, 2021 · Databases

Why GaussDB for Redis Outperforms Open‑Source Redis: Architecture, Benefits, and Real‑World Performance

This article explains the limitations of open‑source Redis, introduces Huawei Cloud's GaussDB for Redis with its compute‑storage separation architecture, details its design, implementation, and disaster‑recovery mechanisms, and summarizes the competitive advantages such as strong consistency, high availability, elastic scaling, and superior performance.

Compute-Storage SeparationGaussDBNoSQL
0 likes · 14 min read
Why GaussDB for Redis Outperforms Open‑Source Redis: Architecture, Benefits, and Real‑World Performance
Code Ape Tech Column
Code Ape Tech Column
Jun 30, 2021 · Databases

Implementing Like Functionality with Redis Bitmaps

This article explains how to use Redis bitmap operations to efficiently implement like, sign‑in, and other binary state features, covering bitmap fundamentals, common use cases, essential commands, Java code examples with Jedis, and range query techniques.

BackendBitmapLike System
0 likes · 7 min read
Implementing Like Functionality with Redis Bitmaps
Wukong Talks Architecture
Wukong Talks Architecture
Jun 29, 2021 · Backend Development

Comprehensive Guide to Spring Cache: A Unified Caching Solution for Redis, Ehcache and Other Middleware

This article introduces Spring Cache as a framework‑agnostic caching abstraction that eliminates manual cache code, explains its core concepts, annotations, configuration options, and demonstrates practical usage with Redis and custom key, condition, and eviction strategies in Spring Boot applications.

BackendCacheEhcache
0 likes · 15 min read
Comprehensive Guide to Spring Cache: A Unified Caching Solution for Redis, Ehcache and Other Middleware
ITPUB
ITPUB
Jun 29, 2021 · Backend Development

Is Redis Distributed Lock Really Safe? A Deep Dive into Redlock, Pitfalls, and Alternatives

This article thoroughly examines the safety of Redis‑based distributed locks, explains basic SETNX locking, explores deadlock and lock‑release problems, presents robust solutions such as atomic SET with expiration, Lua scripts, and unique tokens, and critically compares Redlock with Zookeeper while summarizing expert debates and best‑practice recommendations.

LuaRedlockfault tolerance
0 likes · 34 min read
Is Redis Distributed Lock Really Safe? A Deep Dive into Redlock, Pitfalls, and Alternatives
dbaplus Community
dbaplus Community
Jun 28, 2021 · Cloud Native

From chroot to Kubernetes: Choosing the Right Redis Container Strategy

This talk walks through the evolution of containerization—from early chroot and jails to modern Kubernetes—explains Redis’s core features, compares various container solutions for Redis deployment, and offers practical guidance on installation, scaling, monitoring, and fault recovery in both single‑instance and clustered environments.

ContainerizationDockerKubernetes
0 likes · 30 min read
From chroot to Kubernetes: Choosing the Right Redis Container Strategy
The Dominant Programmer
The Dominant Programmer
Jun 27, 2021 · Backend Development

Cache Database Data in Redis with Custom SpringBoot AOP Annotations

This guide demonstrates how to add a custom AOP‑based caching layer to a SpringBoot application, using Redis to store frequently queried MySQL table data, defining @AopCacheEnable and @AopCacheEvict annotations, implementing an aspect, handling key generation, expiration, and cache eviction on CRUD operations.

CacheCustom AnnotationSpringBoot
0 likes · 9 min read
Cache Database Data in Redis with Custom SpringBoot AOP Annotations
Programmer DD
Programmer DD
Jun 26, 2021 · Backend Development

Implementing a Spring Boot Anti‑Crawler Filter with kk‑anti‑reptile

This article explains how to integrate the kk‑anti‑reptile anti‑crawler component into a Spring Boot application, covering system requirements, filter workflow, rule configuration, Maven setup, Redis and Apollo settings, as well as front‑end handling of the 509 response and captcha verification.

Captchaanti‑crawleraxios
0 likes · 7 min read
Implementing a Spring Boot Anti‑Crawler Filter with kk‑anti‑reptile
Ctrip Technology
Ctrip Technology
Jun 24, 2021 · Backend Development

Design and Implementation of Distributed Cache with Eventual and Strong Consistency at Ctrip Finance

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.

ConsistencyMicroservicesdistributed cache
0 likes · 26 min read
Design and Implementation of Distributed Cache with Eventual and Strong Consistency at Ctrip Finance
Java Architect Essentials
Java Architect Essentials
Jun 23, 2021 · Databases

How Redis Read‑Write Separation Boosts Performance and Cuts Costs

This article explains the background, architecture, and replication models of Redis read‑write separation, compares star and chain replication, and outlines its transparent compatibility, high availability, and performance benefits while noting consistency trade‑offs for read‑heavy workloads.

Database ArchitectureRead-Write Separationhigh availability
0 likes · 9 min read
How Redis Read‑Write Separation Boosts Performance and Cuts Costs
Sohu Tech Products
Sohu Tech Products
Jun 23, 2021 · Backend Development

Using Redis Data Structures for Efficient Large‑Scale Statistics: Cardinality, Sorting, and Aggregation

The article explains how to choose appropriate Redis data structures—such as Bitmap, HyperLogLog, Set, List, Hash, and Sorted Set—to efficiently handle massive statistical scenarios like UV counting, ranking, and set‑based aggregation, while providing concrete command examples and performance considerations.

Data StructuresHyperLogLogSorted Set
0 likes · 13 min read
Using Redis Data Structures for Efficient Large‑Scale Statistics: Cardinality, Sorting, and Aggregation
vivo Internet Technology
vivo Internet Technology
Jun 23, 2021 · Backend Development

Overview of Vivo Mall Promotion System Architecture and Technical Challenges

The article outlines Vivo Mall’s new independent promotion system architecture—introducing a unified discount model, flexible pricing engine, and scalable, high‑concurrency design—while detailing technical solutions such as Redis caching, batching, hot‑cold separation, rate‑limiting, idempotency, circuit‑breaker safeguards, and lessons learned from Redis SCAN and hot‑key issues.

Backend ArchitectureScalabilitypromotion system
0 likes · 12 min read
Overview of Vivo Mall Promotion System Architecture and Technical Challenges
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 23, 2021 · Databases

Redis Concepts and Command Reference

This article introduces Redis as a high‑performance, in‑memory key‑value database, explains its core features such as persistence, pub/sub, data structures, and atomic operations, and provides a comprehensive list of commands for keys, strings, hashes, lists, sets, and sorted sets.

NoSQLcommandskey-value store
0 likes · 15 min read
Redis Concepts and Command Reference
IT Architects Alliance
IT Architects Alliance
Jun 20, 2021 · Databases

Master‑Slave Replication Pitfalls and Deep Dive into Redis Sentinel

This article examines the limitations of Redis master‑slave replication, such as manual failover and single‑node bottlenecks, and provides an in‑depth exploration of Redis Sentinel’s architecture, configuration parameters, detection mechanisms, automatic failover process, and best‑practice recommendations for achieving high availability.

Replicationdatabasefailover
0 likes · 11 min read
Master‑Slave Replication Pitfalls and Deep Dive into Redis Sentinel
IT Architects Alliance
IT Architects Alliance
Jun 20, 2021 · Backend Development

When to Replace In‑Process Cache with Redis? A Practical Guide

This article explains the differences between in‑process caches and external cache services like Redis, outlines the drawbacks of process‑level caching in distributed systems, and provides concrete criteria and strategies for deciding when to migrate to a dedicated cache service.

Backend Architecturecachingprocess cache
0 likes · 9 min read
When to Replace In‑Process Cache with Redis? A Practical Guide
IT Architects Alliance
IT Architects Alliance
Jun 19, 2021 · Backend Development

Mastering Cache Strategies: From CDN to Distributed Systems

This article provides a comprehensive overview of caching in large‑scale distributed systems, covering cache fundamentals, classification, major implementations such as CDN, reverse‑proxy, local, and distributed caches, detailed analyses of Memcached and Redis, common design challenges, and real‑world industry solutions.

BackendCache DesignDistributed Systems
0 likes · 12 min read
Mastering Cache Strategies: From CDN to Distributed Systems
ITPUB
ITPUB
Jun 18, 2021 · Databases

How to Build a Fast Search API with Redis: From Complex SQL to Set‑Based Caching

This article walks through the challenges of implementing a multi‑criteria product search for a shopping site, compares a naïve SQL solution with optimized query splitting, and then shows how Redis sets, sorted sets, and transactions can dramatically improve performance while adding pagination and update handling.

redissearchsql
0 likes · 9 min read
How to Build a Fast Search API with Redis: From Complex SQL to Set‑Based Caching
IT Architects Alliance
IT Architects Alliance
Jun 17, 2021 · Backend Development

A General Cache Handling Mechanism for Static Business Data in Microservice Architecture

The article proposes a comprehensive microservice‑based caching solution for low‑frequency static data such as vehicle models and user profiles, detailing why caching is needed, why Redis and persistent queues are chosen, how consistency checks work, and the trade‑offs compared with simple expiration strategies.

Backend ArchitectureData ConsistencyMicroservices
0 likes · 14 min read
A General Cache Handling Mechanism for Static Business Data in Microservice Architecture
New Oriental Technology
New Oriental Technology
Jun 17, 2021 · Backend Development

Cache Basics, Types, Patterns, and Common Issues

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.

distributed cachejavalocal cache
0 likes · 15 min read
Cache Basics, Types, Patterns, and Common Issues
21CTO
21CTO
Jun 16, 2021 · Backend Development

How to Build a Universal Static Data Cache for Microservices with Redis

This article explains a reusable caching architecture for low‑frequency static data in microservice systems, covering why caching is needed, the role of Redis, persistent queues, consistency checks, and trade‑offs such as cache expiration and operational complexity.

Data ConsistencyMicroservicesQueue
0 likes · 14 min read
How to Build a Universal Static Data Cache for Microservices with Redis
vivo Internet Technology
vivo Internet Technology
Jun 16, 2021 · Backend Development

Troubleshooting Dubbo Thread Pool Exhaustion: A Redis Performance Optimization Case Study

The case study details how a high‑traffic Dubbo service handling 1.8 billion daily requests suffered periodic circuit‑breaks due to thread‑pool exhaustion, traced to a cache‑bypass bug, Redis setex spikes, and an improperly warmed commons‑pool2 connection pool, and resolved by fixing the bug, scaling Redis, and tuning or downgrading the pool configuration to enable pre‑warming via minEvictableIdleTimeMillis.

Circuit BreakingConnection PoolDubbo
0 likes · 13 min read
Troubleshooting Dubbo Thread Pool Exhaustion: A Redis Performance Optimization Case Study
Aikesheng Open Source Community
Aikesheng Open Source Community
Jun 16, 2021 · Databases

High‑Availability Strategies for Redis: Sentinel Service Discovery, VIP Binding, Keepalived VRRP, and Proxy Approaches

The article explains various Redis high‑availability solutions—including Sentinel service discovery, VIP binding, keepalived VRRP, and proxy middleware—for both master‑slave and cluster architectures, and shows how clients can reliably locate the current master node after failover.

JedisProxyhigh availability
0 likes · 7 min read
High‑Availability Strategies for Redis: Sentinel Service Discovery, VIP Binding, Keepalived VRRP, and Proxy Approaches
macrozheng
macrozheng
Jun 15, 2021 · Backend Development

Mastering Redisson: Seamless Distributed Locks in Spring Boot

This tutorial explains what Redisson is, how it extends Redis with powerful distributed data structures and lock mechanisms, and provides step‑by‑step Spring Boot integration, code examples, and detailed testing of re‑entrant, read‑write, and semaphore locks.

Spring Bootconcurrencydistributed-lock
0 likes · 15 min read
Mastering Redisson: Seamless Distributed Locks in Spring Boot
dbaplus Community
dbaplus Community
Jun 14, 2021 · Backend Development

How Redis Evolved from Single‑Threaded to Multi‑Threaded: VM, BIO, and IO Thread Deep Dive

This article traces Redis’s transition from its original single‑threaded design to a multi‑threaded architecture by examining the historical VM thread, the BIO background‑job threads introduced in Redis 2.4 and 4.0, and the network IO threads added in Redis 6.0, complete with source‑code excerpts and detailed explanations of each component’s purpose and implementation.

BIO threadIO threadVM thread
0 likes · 43 min read
How Redis Evolved from Single‑Threaded to Multi‑Threaded: VM, BIO, and IO Thread Deep Dive
Architecture Digest
Architecture Digest
Jun 13, 2021 · Backend Development

Implementing a Real-Time Leaderboard with Redis for a Mobile Game

This article explains how to build a real‑time, dual‑dimension leaderboard for a mobile tank game using Redis Sorted Sets, covering ranking types, composite score calculations, dynamic updates, efficient data retrieval with pipelines, and a complete PHP implementation.

PHPReal-TimeSorted Set
0 likes · 8 min read
Implementing a Real-Time Leaderboard with Redis for a Mobile Game
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 12, 2021 · Databases

Which Redis GUI Reigns Supreme? A Deep Dive into 8 Popular Tools

This article compares eight Redis visualization tools—desktop clients, a web app, and an IDE plugin—detailing their features, pricing, platform support, and usability, while also showing how command‑line tricks can enhance JSON handling, helping developers choose the most efficient solution for their workflow.

Database ManagementGUITool comparison
0 likes · 10 min read
Which Redis GUI Reigns Supreme? A Deep Dive into 8 Popular Tools
Java Backend Technology
Java Backend Technology
Jun 12, 2021 · Databases

Why My Spring API Stalled: Debugging Redis Connection Pool Blocking

A Spring‑based service repeatedly hung because Redis connections were never returned to the pool, leading to thread starvation; the article walks through the investigation using top, jstack, Arthas, and code analysis, then shows the proper way to use RedisCallback and release connections to prevent the deadlock.

Connection PoolJedisdebugging
0 likes · 9 min read
Why My Spring API Stalled: Debugging Redis Connection Pool Blocking
IT Architects Alliance
IT Architects Alliance
Jun 11, 2021 · Backend Development

Understanding Message Queues: From Redis List to Kafka and Pulsar

This article explains the evolution of message‑queue middleware by comparing the basic double‑ended queue implementation, Redis list usage, Kafka’s partitioned log architecture with segment files and sparse indexes, and Pulsar’s compute‑storage separation using BookKeeper, highlighting their designs, strengths, and trade‑offs.

Distributed SystemsKafkaMessage Queue
0 likes · 28 min read
Understanding Message Queues: From Redis List to Kafka and Pulsar
macrozheng
macrozheng
Jun 11, 2021 · Backend Development

How a Faster CRC-64 Boosted Redis Performance: The CRCSpeed Story

An in‑depth look at how mattsta’s CRCSpeed implementation replaced Redis’s original CRC algorithm, delivering up to four‑fold speed gains, the history of its development from 2014 to its 2020 integration, and the performance impact on RDB generation and cluster slot hashing.

CRCalgorithmbackend-development
0 likes · 14 min read
How a Faster CRC-64 Boosted Redis Performance: The CRCSpeed Story
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 10, 2021 · Backend Development

Why Kafka Beats Redis List: A Deep Dive into Message Queue Architecture

This article compares popular message middleware such as Redis, Kafka, and Pulsar, explaining their underlying data structures, strengths and weaknesses, and how concepts like partitions, replication, cursors, and storage segmentation enable high performance, scalability, and reliability in modern distributed messaging systems.

BackendDistributed SystemsKafka
0 likes · 29 min read
Why Kafka Beats Redis List: A Deep Dive into Message Queue Architecture
dbaplus Community
dbaplus Community
Jun 9, 2021 · Databases

How to Enable Multi‑Data‑Center Active‑Active Redis with Bidirectional Sync and rLog

This article explains how a company extended native Redis to support bidirectional synchronization across multiple data‑center sites, addressing issues such as lack of master‑master replication, data loops, idempotency, write conflicts, and providing a custom rLog design for efficient breakpoint‑resume and performance.

Active-ActiveDataSyncReplication
0 likes · 16 min read
How to Enable Multi‑Data‑Center Active‑Active Redis with Bidirectional Sync and rLog
Java Interview Crash Guide
Java Interview Crash Guide
Jun 9, 2021 · Backend Development

Designing a Universal Static Data Cache for Microservice Architectures

This article examines the challenges of caching low‑frequency static data in microservice systems and proposes a comprehensive solution that combines business services, Redis, persistent queues, and consistency‑checking programs to achieve high‑performance, near‑real‑time data access while mitigating cache‑related risks.

ConsistencyMicroservicesQueue
0 likes · 13 min read
Designing a Universal Static Data Cache for Microservice Architectures
Java Interview Crash Guide
Java Interview Crash Guide
Jun 8, 2021 · Backend Development

Why Did Our Spring API Hang? Uncovering Redis Connection Pool Blocking

After a week of intermittent API hangs in an internal sandbox, we traced the issue to Redis connection pool blocking caused by missing max‑wait configuration, leading to threads waiting indefinitely; by adjusting Jedis pool settings, using proper connection release, and avoiding unsupported commands, the deadlock was resolved.

Connection PoolJedisdebugging
0 likes · 9 min read
Why Did Our Spring API Hang? Uncovering Redis Connection Pool Blocking
21CTO
21CTO
Jun 3, 2021 · Backend Development

How to Prevent Duplicate Requests on the Server Using Redis and Request Hashing

This article explains how to handle duplicate user requests—especially write operations—by using unique request IDs with Redis, computing MD5 hashes of sorted JSON parameters, and providing a Java helper class to reliably deduplicate requests on the server side.

MD5deduplicationjava
0 likes · 8 min read
How to Prevent Duplicate Requests on the Server Using Redis and Request Hashing
macrozheng
macrozheng
Jun 3, 2021 · Backend Development

How Redis Starts: Inside the Server’s Event Loop and Reactor Model

This article walks through Redis's startup sequence, explaining how the server creates a listening socket, registers events with the aeFileEvent system, runs a single‑threaded select‑based event loop, and processes client commands using the Reactor pattern, complete with code examples and diagrams.

Network programmingReactor PatternSingle Thread
0 likes · 8 min read
How Redis Starts: Inside the Server’s Event Loop and Reactor Model
Java Architect Essentials
Java Architect Essentials
Jun 1, 2021 · Information Security

API Security Practices: Token, Timestamp, Signature, and Replay Prevention in Spring Boot

This article explains how to protect data exchange with third‑party systems by using access tokens, timestamps, cryptographic signatures, and duplicate‑submission safeguards, providing detailed Java/Spring Boot examples and code snippets for implementing secure API authentication and request validation.

API SecuritySpring BootThreadLocal
0 likes · 27 min read
API Security Practices: Token, Timestamp, Signature, and Replay Prevention in Spring Boot
Code Ape Tech Column
Code Ape Tech Column
Jun 1, 2021 · Databases

Tendis Hybrid Storage Architecture and Key Features

The article introduces the pain points of using Redis at Tencent IEG, explains the three Tendis product editions, and provides an in‑depth description of the hybrid storage version’s architecture, components, version control, cold‑hot data interaction, scaling mechanisms, and the stateless Redis‑sync layer.

CacheHybrid storageRocksDB
0 likes · 16 min read
Tendis Hybrid Storage Architecture and Key Features
IT Architects Alliance
IT Architects Alliance
May 31, 2021 · Databases

40 Common Redis Interview Questions and Answers

This article compiles 40 frequently asked Redis interview questions covering fundamentals, data types, persistence, clustering, performance tuning, memory optimization, security, and advanced usage such as pipelines and distributed locks, providing concise answers to help candidates prepare confidently for technical interviews.

cachingdatabaseinterview
0 likes · 20 min read
40 Common Redis Interview Questions and Answers
Architect's Tech Stack
Architect's Tech Stack
May 31, 2021 · Databases

Tendis Hybrid Storage Architecture: Design, Features, and Implementation Details

This article introduces the pain points of using Redis as a cache, presents Tencent's Tendis solution with its three product variants, and provides an in‑depth explanation of the hybrid storage version’s overall architecture, component functions, version control, cold‑hot data interaction, eviction policies, and scaling mechanisms.

CacheCuckoo FilterHybrid storage
0 likes · 17 min read
Tendis Hybrid Storage Architecture: Design, Features, and Implementation Details
IT Architects Alliance
IT Architects Alliance
May 30, 2021 · Backend Development

Transparent Multilevel Cache (TMC): Architecture, Hotspot Detection, and Local Cache Implementation

The article introduces Transparent Multilevel Cache (TMC), a comprehensive caching solution that adds hotspot detection and local caching to existing distributed cache systems, explains its three‑layer architecture, transparent Java integration, real‑time hotspot discovery process, and demonstrates performance gains in high‑traffic e‑commerce scenarios.

CacheDistributed Systemshotspot detection
0 likes · 13 min read
Transparent Multilevel Cache (TMC): Architecture, Hotspot Detection, and Local Cache Implementation
MaGe Linux Operations
MaGe Linux Operations
May 29, 2021 · Databases

40 Must‑Know Redis Interview Questions to Ace Your Next Job

This article compiles 40 common Redis interview questions and detailed answers, covering Redis fundamentals, data types, persistence mechanisms, performance characteristics, clustering, replication, memory optimization, eviction policies, and practical usage scenarios to help candidates confidently succeed in technical interviews.

Persistencecachingdatabase
0 likes · 23 min read
40 Must‑Know Redis Interview Questions to Ace Your Next Job
Selected Java Interview Questions
Selected Java Interview Questions
May 27, 2021 · Backend Development

Java Backend Interview Experience: Spring, Nacos, Redis, SQL Optimization and More

The article shares a developer's post‑interview reflections covering self‑introduction, Spring ecosystem usage, Nacos vs Eureka service discovery, SpringBoot startup mechanics, design patterns, Linux commands, Redis operations, Excel POI handling, SQL optimization techniques, and other practical interview questions.

NacosSpringBootinterview
0 likes · 9 min read
Java Backend Interview Experience: Spring, Nacos, Redis, SQL Optimization and More
Liangxu Linux
Liangxu Linux
May 27, 2021 · Operations

How I Built an Automated Redis Sentinel to Seamlessly Handle Failover

A sysadmin narrates how he monitors four Redis nodes, detects master failure with PING, promotes a slave using SLAVEOF, reconfigures the remaining replicas, and ultimately automates the entire process with a custom Sentinel program and a multi‑node Sentinel cluster for high availability.

Operationsautomationc++
0 likes · 11 min read
How I Built an Automated Redis Sentinel to Seamlessly Handle Failover
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 26, 2021 · Databases

How to Store Billions of IDs in Redis Without Running Out of Memory

This article examines the challenges of storing massive DMP ID mappings in Redis—including memory fragmentation, expansion, and latency constraints—and presents eviction, bucket‑hashing, and fragmentation‑reduction techniques to achieve efficient, real‑time, large‑scale key‑value storage.

Key-value hashingMemory Optimizationdata engineering
0 likes · 11 min read
How to Store Billions of IDs in Redis Without Running Out of Memory