BestHub
Sign in
Tagged articles

Redis

3508 articles · Page 25 of 36
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.

JavaLettuceRedis
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.

DatabaseOperationsPerformance
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.

EhcacheJavaRedis
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.

JavaRedisbackend development
0 likes · 12 min read
Designing a Transparent RPC Framework for Distributed Data Access and Its Application in Redis Cluster
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.

DMPJavaKey hashing
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.

BitMapDatabaseJava
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.

CacheEhcacheJava
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.

LuaRedisRedlock
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.

DockerKubernetesNamespace
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.

AOPCacheCustom Annotation
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.

CAPTCHARedisanti‑crawler
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.

MySQLRedisconsistency
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 ArchitecturePerformanceRead-Write Separation
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 StructuresHyperLogLogRedis
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.

Redisbackend architecturepromotion 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.

NoSQLRediscommands
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.

DatabaseFailoverRedis
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.

Redisbackend architecturecaching
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.

Cache DesignMemcachedPerformance
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.

RedisSQLsearch
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.

Data ConsistencyQueueRedis
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.

JavaPerformanceRedis
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 ConsistencyQueueRedis
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.

DubboPerformance OptimizationRedis
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.

RedisSentinelhigh 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.

JavaRedisRedisson
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 threadRedis
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.

LeaderboardPHPRedis
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 ManagementGUIPerformance
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.

DebuggingJavaPerformance
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.

KafkaMessage QueueRedis
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.

AlgorithmCRCPerformance Optimization
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.

KafkaRedisbackend
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-ActiveDataSyncRedis
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.

QueueRediscaching
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.

DebuggingJavaRedis
0 likes · 9 min read
Why Did Our Spring API Hang? Uncovering Redis Connection Pool Blocking
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.

Reactor patternRedisbackend development
0 likes · 8 min read
How Redis Starts: Inside the Server’s Event Loop and Reactor Model
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 storageRedis
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.

DatabaseInterviewPerformance
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 FilterDatabase
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.

CacheJavaRedis
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.

DatabaseInterviewPersistence
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.

InterviewJavaNacos
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.

AutomationC++Failover
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 hashingRedisdata engineering
0 likes · 11 min read
How to Store Billions of IDs in Redis Without Running Out of Memory
Programmer DD
Programmer DD
May 25, 2021 · Backend Development

How to Prevent Lost Orders in Payment Systems: Proven Backend Strategies

This article explains the typical order‑payment flow, identifies common causes of lost orders—both external and internal—and provides concrete backend techniques such as intermediate payment states, timeout queries, idempotent notifications, and Redis‑based duplicate‑submission prevention to ensure reliable order processing.

RedisWeChat Payidempotency
0 likes · 5 min read
How to Prevent Lost Orders in Payment Systems: Proven Backend Strategies
Baidu Geek Talk
Baidu Geek Talk
May 24, 2021 · Big Data

Real-Time Quantile Computation Using TDigest: Architecture and Solutions

The article presents a real‑time quantile solution using the TDigest data structure, which clusters data into centroids and stores digests in Redis or Doris, pre‑computes quantiles for all dimension combinations, and provides a reusable API that delivers fast, accurate, low‑memory quantile statistics for diverse business scenarios.

DorisRedisStream Processing
0 likes · 11 min read
Real-Time Quantile Computation Using TDigest: Architecture and Solutions
dbaplus Community
dbaplus Community
May 23, 2021 · Databases

Hidden Redis Pitfalls That Can Crash Your System

This article enumerates common Redis pitfalls—including unexpected key expiration loss, command‑induced blocking, memory‑intensive bitmap operations, AOF and RDB persistence issues, and master‑slave replication quirks—explaining their causes, real‑world impact, and practical mitigation steps.

CommandMemoryPerformance
0 likes · 29 min read
Hidden Redis Pitfalls That Can Crash Your System
Wukong Talks Architecture
Wukong Talks Architecture
May 21, 2021 · Backend Development

Using Redisson for Distributed Locks in Spring Boot

This article explains how to integrate Redisson into a Spring Boot application to implement various Redis‑based distributed synchronization primitives—including re‑entrant locks, read‑write locks, and semaphores—while covering configuration, code examples, the watchdog mechanism, and practical testing procedures.

JavaRedisRedisson
0 likes · 12 min read
Using Redisson for Distributed Locks in Spring Boot
21CTO
21CTO
May 20, 2021 · Backend Development

From Monolith to Scalable Order System: Lessons from Ele.me’s 4‑Year Evolution

Over four years at Ele.me, the author chronicles the transformation of the order platform from a single‑machine Python monolith to a distributed, sharded, message‑driven architecture, detailing challenges in scaling, performance testing, fault injection, Redis usage, and service separation that shaped today’s robust backend.

Redismessagingmicroservices
0 likes · 49 min read
From Monolith to Scalable Order System: Lessons from Ele.me’s 4‑Year Evolution
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 20, 2021 · Backend Development

Designing a High‑Concurrency Flash‑Sale (秒杀) System: From Naïve Implementation to Optimized Solutions

This article walks through the design of a flash‑sale system, starting with a simple SpringBoot‑MyBatis implementation, then addressing overselling with pessimistic and optimistic locks, applying rate‑limiting algorithms, time‑window controls, interface hiding, frequency limits, and a suite of production‑grade optimizations such as CDN, Nginx load balancing, Redis caching, message queues, and short‑URL handling.

RedisSpringBootflash sale
0 likes · 14 min read
Designing a High‑Concurrency Flash‑Sale (秒杀) System: From Naïve Implementation to Optimized Solutions
vivo Internet Technology
vivo Internet Technology
May 19, 2021 · Backend Development

Design and Evolution of Vivo Live‑Streaming IM Message System

Vivo’s live‑streaming IM system combines short‑polling and long‑connection techniques, Redis SortedSet storage, priority‑based routing, protobuf compression, and discard strategies to deliver a fault‑tolerant, high‑concurrency messaging backbone that scales with growing traffic and diverse message types.

Instant MessagingRedisbackend architecture
0 likes · 20 min read
Design and Evolution of Vivo Live‑Streaming IM Message System
Su San Talks Tech
Su San Talks Tech
May 16, 2021 · Backend Development

Mastering Distributed Locks with Redis: From Bronze to Diamond Solutions

This article examines why local locks fail in distributed systems, introduces Redis‑based distributed locking, and walks through five progressive solutions—from a simple SETNX implementation to atomic Lua scripts—highlighting each approach's drawbacks and how to mitigate them.

Redisbackendsetnx
0 likes · 16 min read
Mastering Distributed Locks with Redis: From Bronze to Diamond Solutions
DeWu Technology
DeWu Technology
May 14, 2021 · Backend Development

Local and Distributed Caching: Concepts and Implementations

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.

CaffeineGuavaJava
0 likes · 20 min read
Local and Distributed Caching: Concepts and Implementations
Practical DevOps Architecture
Practical DevOps Architecture
May 14, 2021 · Databases

Redis Basic Commands and Key Operations Tutorial

This article provides a concise tutorial on essential Redis commands, covering basic operations, database selection, key management, expiration settings, and practical examples demonstrated through the Redis CLI, including how to list keys with patterns, check existence, and clear databases.

DatabaseRedisTTL
0 likes · 7 min read
Redis Basic Commands and Key Operations Tutorial
Efficient Ops
Efficient Ops
May 11, 2021 · Big Data

How to Store Billions of Keys in Redis: Cut Memory, Reduce Fragmentation, and Scale Real‑Time DMP

This article examines the challenges of storing massive DMP data in Redis, analyzes memory fragmentation, key‑size issues, and latency constraints, and presents practical strategies such as TTL eviction, bucket‑hashing, custom key compression, and fragmentation‑reduction techniques to enable scalable, real‑time querying.

BucketIdDMPHashing
0 likes · 11 min read
How to Store Billions of Keys in Redis: Cut Memory, Reduce Fragmentation, and Scale Real‑Time DMP
Practical DevOps Architecture
Practical DevOps Architecture
May 10, 2021 · Databases

Redis Advantages, Disadvantages, Use Cases, Shutdown Methods, and Configuration Guide

This article outlines Redis's key advantages such as high performance and flexible data types, discusses its limitations like lack of relational features, describes ideal in‑memory use cases, compares it with Memcached, and provides detailed instructions for shutting down, configuring, and connecting to Redis using command‑line and graphical clients.

ClientConfigurationDatabase
0 likes · 4 min read
Redis Advantages, Disadvantages, Use Cases, Shutdown Methods, and Configuration Guide
Code Ape Tech Column
Code Ape Tech Column
May 10, 2021 · Industry Insights

Why Kafka Beats Redis List: A Deep Dive into Modern Messaging Middleware

This article compares Redis list, Kafka, and Pulsar as messaging middleware, explaining their architectures, strengths, and weaknesses—including queue fundamentals, partitioning, cursor management, consumer groups, high‑availability mechanisms, storage strategies, and consumption models—to help readers choose the right solution for large‑scale systems.

KafkaRedisdistributed systems
0 likes · 30 min read
Why Kafka Beats Redis List: A Deep Dive into Modern Messaging Middleware
Architect
Architect
May 9, 2021 · Databases

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

Redis read/write separation introduces read‑only replicas to offload read traffic, offering two replication models—star replication with direct master‑replica sync and chain replication forming a replication chain—each with distinct performance, scalability, and latency trade‑offs, while maintaining high availability and transparent compatibility.

Database ArchitectureRead-Write SeparationRedis
0 likes · 7 min read
Redis Read/Write Separation Architecture: Star vs. Chain Replication
Selected Java Interview Questions
Selected Java Interview Questions
May 8, 2021 · Databases

Cache Consistency Strategies for MySQL Using Redis

This article examines why caching is needed for MySQL, discusses consistency challenges, and compares four Redis‑based solutions—including expiration, synchronous updates, Kafka‑mediated async updates, and binlog replication—offering guidance on selecting the appropriate approach based on latency and reliability requirements.

Cache ConsistencyDatabase CachingMySQL
0 likes · 9 min read
Cache Consistency Strategies for MySQL Using Redis
Java Architect Essentials
Java Architect Essentials
May 7, 2021 · Backend Development

Comprehensive Spring Boot Integration Guide: Swagger, Redis, MyBatis, Druid, Mail, CORS, AOP and More

This article provides a step‑by‑step tutorial on building a Spring Boot project, covering project generation, core starters, automatic Redis configuration, common annotations like @SpringBootApplication and @ControllerAdvice, web container and HTTPS settings, profile management, CORS, MVC interceptors, AOP, MyBatis‑Druid integration, mail sending, and Swagger API documentation.

IntegrationMailMyBatis
0 likes · 18 min read
Comprehensive Spring Boot Integration Guide: Swagger, Redis, MyBatis, Druid, Mail, CORS, AOP and More
macrozheng
macrozheng
May 6, 2021 · Operations

How I Built an Automated Redis Sentinel System to Handle Failover

An operations engineer narrates how he monitors a four‑node Redis cluster, detects master failure with continuous PINGs, promotes a slave to master, reconfigures replicas, and automates the entire process with a sentinel program and a sentinel cluster for high availability.

AutomationFailoverRedis
0 likes · 11 min read
How I Built an Automated Redis Sentinel System to Handle Failover
Architecture Digest
Architecture Digest
May 2, 2021 · Backend Development

Preventing Order Loss and Duplicate Submissions in Payment Systems

This article explains the typical payment flow, identifies causes of external and internal order loss, and provides concrete backend strategies—including intermediate payment states, timeout queries, idempotent handling, retry mechanisms, and Redis‑based duplicate‑submission protection—to ensure reliable order processing.

RedisRetryWeChat Pay
0 likes · 4 min read
Preventing Order Loss and Duplicate Submissions in Payment Systems
Architect
Architect
Apr 30, 2021 · Backend Development

Designing a Scalable Real‑Time Data Warehouse with Redis: Challenges and Solutions

The article analyzes the massive storage and performance challenges of a real‑time DMP cache built on Redis, outlines data characteristics and technical obstacles, and proposes eviction policies, bucket‑based hashing, and fragmentation‑reduction techniques with Java code examples to achieve billion‑scale in‑memory key‑value storage.

JavaReal-time Data WarehouseRedis
0 likes · 10 min read
Designing a Scalable Real‑Time Data Warehouse with Redis: Challenges and Solutions
Top Architect
Top Architect
Apr 30, 2021 · Backend Development

Redis Distributed Lock Failure Causing Overselling and Safer Lock Solutions

This article analyzes a real‑world flash‑sale incident where a Redis distributed lock expired under high concurrency, leading to massive overselling, and presents safer lock implementations, atomic stock checks, and architectural improvements to prevent similar failures.

JavaRedisconcurrency
0 likes · 11 min read
Redis Distributed Lock Failure Causing Overselling and Safer Lock Solutions
Wukong Talks Architecture
Wukong Talks Architecture
Apr 29, 2021 · Backend Development

Distributed Lock Implementations with Redis: From Local Locks to Bronze, Silver, Gold, Platinum, and Diamond Solutions

This article explains why local in‑memory locks fail in distributed environments, introduces the concept of distributed locks, and walks through five progressive Redis‑based lock implementations—bronze, silver, gold, platinum, and diamond—detailing their principles, code examples, advantages, and shortcomings.

JavaRedisbackend
0 likes · 16 min read
Distributed Lock Implementations with Redis: From Local Locks to Bronze, Silver, Gold, Platinum, and Diamond Solutions
Architect's Tech Stack
Architect's Tech Stack
Apr 29, 2021 · Databases

Analyzing Redis Latency Issues and How to Diagnose Them

This article explains common causes of Redis latency spikes—including slow commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—and provides step‑by‑step diagnostic commands and practical mitigation techniques.

Memory ManagementRedisdatabase operations
0 likes · 18 min read
Analyzing Redis Latency Issues and How to Diagnose Them
vivo Internet Technology
vivo Internet Technology
Apr 28, 2021 · Backend Development

A Beginner's Guide to Building a Simple Live Streaming System with LiveGo, OBS, and flv.js

This guide walks beginners through setting up a basic live‑streaming pipeline using the open‑source LiveGo server, OBS for RTMP publishing, and flv.js for browser playback, while explaining push‑pull architecture, protocol choices, Docker deployment, and a Redis‑based chat system for live rooms.

OBSRedisbackend development
0 likes · 20 min read
A Beginner's Guide to Building a Simple Live Streaming System with LiveGo, OBS, and flv.js