BestHub
Sign in
Tagged articles

Redis

3508 articles · Page 23 of 36
IT Architects Alliance
IT Architects Alliance
Oct 27, 2021 · Backend Development

Designing a Robust Flash‑Sale (秒杀) System: Architecture, High Concurrency Handling, and Rate‑Limiting Strategies

This article examines the challenges of building a flash‑sale system—such as overselling, massive concurrent requests, URL exposure, and database pressure—and presents a comprehensive backend design that includes dedicated databases, dynamic URLs, static pages, Redis clustering, Nginx load balancing, SQL optimization, token‑bucket rate limiting, asynchronous order processing, and service degradation techniques.

JavaRedisbackend architecture
0 likes · 14 min read
Designing a Robust Flash‑Sale (秒杀) System: Architecture, High Concurrency Handling, and Rate‑Limiting Strategies
IT Architects Alliance
IT Architects Alliance
Oct 27, 2021 · Backend Development

Common Mistakes When Building Microservices and Lessons Learned

The article reviews the most frequent errors encountered while adopting microservice architecture—excessive customization, uncontrolled complexity, and vague definitions—illustrating each with real‑world experiences, a saga implementation using Redis streams and Go, and practical advice to avoid similar pitfalls.

GoRedisSAGA
0 likes · 6 min read
Common Mistakes When Building Microservices and Lessons Learned
Architect
Architect
Oct 27, 2021 · Databases

Understanding Redis Persistence: RDB and AOF Mechanisms

This article explains how Redis, an in‑memory key‑value store, ensures data durability through two persistence methods—RDB snapshots and AOF command logging—detailing their commands, internal workflows, file structures, configuration options, and trade‑offs between safety and performance.

AOFData durabilityPersistence
0 likes · 13 min read
Understanding Redis Persistence: RDB and AOF Mechanisms
vivo Internet Technology
vivo Internet Technology
Oct 27, 2021 · Databases

Analysis of Jedis Client Access Modes and Implementation Details

The article examines Jedis 3.5.0’s three Redis access modes—single‑node via Jedis, sharding via ShardedJedis, and cluster via JedisCluster—detailing their class hierarchies, connection handling, consistent‑hashing and slot logic, and how pipelines boost throughput while respecting mode‑specific constraints.

ClientClusterJava
0 likes · 23 min read
Analysis of Jedis Client Access Modes and Implementation Details
Top Architect
Top Architect
Oct 27, 2021 · Backend Development

Implementation Strategies for Delayed Tasks in Java Applications

The article explains the concept of delayed tasks, distinguishes them from scheduled tasks, and evaluates five practical implementation approaches—including database polling, JDK DelayQueue, Netty time‑wheel, Redis sorted‑set and key‑space notifications, and RabbitMQ delayed queues—while providing code samples, performance pros and cons, and deployment considerations.

JavaQuartzRedis
0 likes · 20 min read
Implementation Strategies for Delayed Tasks in Java Applications
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 25, 2021 · Databases

Common Redis Pitfalls and How to Avoid Them

This article examines frequent Redis pitfalls—including unexpected key expiration, blocking DEL commands, RANDOMKEY performance issues, SETBIT memory spikes, MONITOR OOM risks, persistence challenges, and master‑slave replication quirks—providing detailed explanations and practical mitigation strategies for each scenario.

CachePerformancePersistence
0 likes · 29 min read
Common Redis Pitfalls and How to Avoid Them
dbaplus Community
dbaplus Community
Oct 24, 2021 · Backend Development

Fixing 18B Daily Dubbo Calls: Solving Redis Connection Pool Exhaustion

When a Dubbo interface handling 18 billion daily requests began failing due to thread‑pool exhaustion, a systematic investigation uncovered traffic spikes, Redis request overload, and mis‑configured connection‑pool parameters, leading to a series of targeted fixes—including timeout adjustments, Redis scaling, and pool‑parameter tuning—that restored stability and dramatically reduced error rates.

DubboJavaPerformance Optimization
0 likes · 16 min read
Fixing 18B Daily Dubbo Calls: Solving Redis Connection Pool Exhaustion
Python Programming Learning Circle
Python Programming Learning Circle
Oct 23, 2021 · Backend Development

Comprehensive Guide to Using Celery for Distributed Task Processing in Python

This article provides a detailed overview of Celery, covering its architecture, common use cases, installation steps, project structure, task definition, periodic tasks, worker management, distributed deployment, advanced monitoring, custom task handling, task routing, and monitoring with Flower, all illustrated with practical code examples.

AsynchronousDistributed TasksRedis
0 likes · 12 min read
Comprehensive Guide to Using Celery for Distributed Task Processing in Python
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 23, 2021 · Backend Development

Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices

This article thoroughly examines how Redis distributed locks work, the safety challenges they face—including deadlocks, lock expiration, and node failures—explores the Redlock algorithm and its controversies, compares Redis with Zookeeper implementations, and offers practical guidelines and best‑practice solutions for reliable distributed locking.

RedisRedlockconcurrency
0 likes · 32 min read
Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 22, 2021 · Backend Development

How to Effectively Read Redis Source Code: A Step‑by‑Step Guide

This article presents a practical seven‑step methodology for efficiently reading Redis's source code—starting with project mapping, preparing prerequisite knowledge, tackling basic modules, following the core execution flow, using a whole‑before‑detail approach, exploring side features, and finally filling knowledge gaps—applicable to other large codebases as well.

Redisreading strategysoftware engineering
0 likes · 13 min read
How to Effectively Read Redis Source Code: A Step‑by‑Step Guide
Programmer DD
Programmer DD
Oct 22, 2021 · Backend Development

Implementing Automatic Idempotency in Spring Boot with Redis and Interceptors

This tutorial explains the concept of idempotency in web APIs and demonstrates a complete Spring Boot solution using Redis, custom annotations, token validation, and interceptor configuration to ensure that each request modifies the database only once, even under repeated calls.

AnnotationInterceptorJava
0 likes · 12 min read
Implementing Automatic Idempotency in Spring Boot with Redis and Interceptors
Aikesheng Open Source Community
Aikesheng Open Source Community
Oct 20, 2021 · Databases

Real-Time Slow Query Monitoring Architecture for MySQL

This article describes a real‑time slow‑query monitoring solution for MySQL, detailing the overall architecture, the agent that tails slow‑log files and pushes entries to Redis, and the consumer that processes logs, stores them, and alerts DBAs, enabling near‑instant detection of performance issues.

MySQLRedisSlow Query
0 likes · 6 min read
Real-Time Slow Query Monitoring Architecture for MySQL
Laravel Tech Community
Laravel Tech Community
Oct 19, 2021 · Backend Development

Redis Scaling Strategies: Partitioning, Master‑Slave Replication, Sentinel, and Cluster

This article introduces various Redis scaling solutions—including basic partitioning, master‑slave replication, Sentinel high‑availability, and Redis Cluster—explaining their concepts, typical usage patterns, configuration commands, advantages, and drawbacks to help developers choose the right approach for high‑traffic environments.

ClusterRedisReplication
0 likes · 12 min read
Redis Scaling Strategies: Partitioning, Master‑Slave Replication, Sentinel, and Cluster
政采云技术
政采云技术
Oct 19, 2021 · Backend Development

Debugging Maven Multi‑module Deployment Issues Caused by JDK Constant Compilation Optimization

This article analyzes a Maven multi‑module project where a static constant change in a shared API module caused unexpected Redis key errors at runtime due to JDK compile‑time constant folding, outlines the investigation steps, identifies the root cause, and provides best‑practice recommendations for version management.

Build OptimizationDebuggingJava
0 likes · 5 min read
Debugging Maven Multi‑module Deployment Issues Caused by JDK Constant Compilation Optimization
Programmer DD
Programmer DD
Oct 18, 2021 · Databases

Master Redis Monitoring: Key Metrics, Commands, and Performance Tips

This article explains how to monitor Redis by categorizing essential performance, memory, activity, persistence, and error metrics, provides detailed tables of metric names and descriptions, lists common monitoring tools, shows configuration snippets, and demonstrates useful Redis CLI commands for real‑time insight.

CLIDatabaseRedis
0 likes · 7 min read
Master Redis Monitoring: Key Metrics, Commands, and Performance Tips
Top Architect
Top Architect
Oct 17, 2021 · Cloud Native

How Redis Simplifies Microservice Design Patterns, Distributed Transactions, and Observability

This article explains how Redis can be used to implement and simplify a wide range of microservice design patterns—including bounded contexts, asynchronous messaging, orchestrated sagas, transaction inboxes, telemetry, event sourcing, CQRS, and shared data—while improving performance, scalability, and observability in cloud‑native architectures.

CQRSRediscloud native
0 likes · 16 min read
How Redis Simplifies Microservice Design Patterns, Distributed Transactions, and Observability
Top Architect
Top Architect
Oct 16, 2021 · Databases

Redis Scaling Strategies: Partitioning, Master‑Slave, Sentinel, and Cluster

This article explains the main Redis scaling approaches—including simple partitioning, master‑slave replication, Sentinel high‑availability, and native Cluster—detailing their concepts, usage methods, advantages, drawbacks, and providing practical configuration commands and code examples.

ClusterMaster‑SlaveRedis
0 likes · 12 min read
Redis Scaling Strategies: Partitioning, Master‑Slave, Sentinel, and Cluster
High Availability Architecture
High Availability Architecture
Oct 16, 2021 · Backend Development

Ensuring Data Consistency Between MySQL and Redis: Strategies for Single‑Threaded and Multi‑Threaded Scenarios

This article explains what data consistency means for MySQL and Redis, analyzes inconsistency cases in both single‑threaded and concurrent environments, and proposes practical strategies—including read‑only and read‑write cache handling, message‑queue retries, binlog subscription, delayed double‑delete, and distributed locking—to achieve eventual or strong consistency.

Data ConsistencyDistributed LocksMessage Queue
0 likes · 16 min read
Ensuring Data Consistency Between MySQL and Redis: Strategies for Single‑Threaded and Multi‑Threaded Scenarios
Dada Group Technology
Dada Group Technology
Oct 15, 2021 · Backend Development

Redis Cache Optimization and Architecture Evolution in JD Daojia Coupon System

This article details the JD Daojia coupon system's high‑traffic architecture, describing its multi‑layer design, Redis cache challenges such as large‑key and hot‑key issues, and practical optimization techniques including key redesign, expiration strategies, and active‑expire algorithms to improve performance and scalability.

Cache OptimizationPerformanceRedis
0 likes · 17 min read
Redis Cache Optimization and Architecture Evolution in JD Daojia Coupon System
Architect
Architect
Oct 15, 2021 · Databases

Performance Analysis and Optimization of Redis Cluster CLUSTER SLOTS Command

This article investigates the high CPU usage and latency observed after expanding a large Redis cluster, analyzes the root cause in the CLUSTER SLOTS implementation and client MOVED handling, proposes an optimized slot‑traversal algorithm, and demonstrates significant performance improvements through benchmarking and profiling.

C++ClusterDatabase
0 likes · 18 min read
Performance Analysis and Optimization of Redis Cluster CLUSTER SLOTS Command
Top Architect
Top Architect
Oct 14, 2021 · Cloud Native

Rate Limiting in Spring Cloud Gateway: Algorithms, Implementations, and Practical Guide

This article provides a comprehensive overview of rate‑limiting techniques for Spring Cloud Gateway, covering common scenarios, classic algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and practical implementations using Redis, Resilience4j, Bucket4j, Guava and custom local limiters.

RedisResilience4jmicroservices
0 likes · 41 min read
Rate Limiting in Spring Cloud Gateway: Algorithms, Implementations, and Practical Guide
Open Source Linux
Open Source Linux
Oct 13, 2021 · Backend Development

Unlock 16 Powerful Redis Patterns for Scalable Backend Systems

This guide explores sixteen practical Redis use cases—from caching and distributed locks to rate limiting, bitmaps, shopping carts, timelines, and ranking—detailing data types, commands, and implementation tips that help developers build efficient, scalable backend services.

BitmapsMessage QueueRedis
0 likes · 9 min read
Unlock 16 Powerful Redis Patterns for Scalable Backend Systems
vivo Internet Technology
vivo Internet Technology
Oct 13, 2021 · Databases

Performance Analysis and Optimization of Redis Cluster CLUSTER SLOTS Command

In large Redis clusters the original CLUSTER SLOTS implementation traversed every master and all 16,384 slots, causing ~52 % CPU usage and high MGET latency during migrations, but redesigning it to iterate the pre‑built slot array reduced complexity to O(total slots), cutting execution time from 2 ms to 0.17 ms and eliminating the CPU hotspot, a fix now merged into Redis 6.2.2.

C++ClusterJava
0 likes · 20 min read
Performance Analysis and Optimization of Redis Cluster CLUSTER SLOTS Command
Tencent Cloud Developer
Tencent Cloud Developer
Oct 13, 2021 · Databases

Ensuring Data Consistency Between MySQL and Redis: Strategies and Best Practices

To keep MySQL and Redis synchronized, the article defines consistency, examines read‑only and read‑write cache inconsistency cases, and recommends practical strategies such as update‑DB‑then‑delete‑cache with message‑queue retries, binlog‑driven updates, delayed double‑delete, and Redis distributed locks, while outlining stronger protocols and key design considerations.

Data ConsistencyMySQLRedis
0 likes · 15 min read
Ensuring Data Consistency Between MySQL and Redis: Strategies and Best Practices
Architect
Architect
Oct 11, 2021 · Databases

How to Efficiently Read Redis Source Code: A Step-by-Step Guide

This article presents a practical, seven‑step methodology for efficiently reading Redis source code, covering project mapping, prerequisite knowledge, starting from basic modules, identifying the core execution path, balancing overall structure with detailed logic, handling auxiliary features, and performing targeted gap‑filling to master the codebase.

DatabaseRedisSoftware Architecture
0 likes · 14 min read
How to Efficiently Read Redis Source Code: A Step-by-Step Guide
Su San Talks Tech
Su San Talks Tech
Oct 9, 2021 · Databases

20 Essential Redis Interview Questions Every Engineer Should Know

This comprehensive guide covers Redis fundamentals, data structures, performance tricks, cache pitfalls, expiration policies, persistence options, high‑availability architectures, distributed locking techniques, and practical use‑cases, providing clear explanations and code examples for each topic.

CacheDistributedLockInterview
0 likes · 57 min read
20 Essential Redis Interview Questions Every Engineer Should Know
Programmer DD
Programmer DD
Oct 9, 2021 · Databases

Mastering Redis Locks: From SETNX to RedLock and Redisson

This article explains the fundamentals of Redis locking mechanisms, covering SETNX usage, the pitfalls of naive implementations, Lua‑based atomic unlock scripts, the Redisson client library, and the RedLock algorithm, while providing practical code examples and diagrams to illustrate each concept.

LuaRedisRedisson
0 likes · 10 min read
Mastering Redis Locks: From SETNX to RedLock and Redisson
Java Tech Enthusiast
Java Tech Enthusiast
Oct 8, 2021 · Backend Development

How to Share Session Across Distributed SpringBoot Services with Redis and Spring Session

This article walks through the challenges of sharing HTTP session data between micro‑services in a distributed SpringBoot architecture, demonstrates a Redis‑based manual solution, introduces Spring Session for transparent session clustering, and resolves OpenFeign cookie loss with a request interceptor.

OpenFeignRedisSpring Session
0 likes · 12 min read
How to Share Session Across Distributed SpringBoot Services with Redis and Spring Session
IT Architects Alliance
IT Architects Alliance
Oct 7, 2021 · Backend Development

Designing a High‑Concurrency Ticket Spike System with Load Balancing, Redis, and Go

This article explains how to build a high‑concurrency ticket‑seckill system that can handle millions of simultaneous requests by using multi‑layer load balancing, Nginx weighted round‑robin, local stock deduction, Redis atomic scripts, and Go’s native concurrency, and it demonstrates the implementation with complete code and performance testing.

Distributed ArchitectureGoRedis
0 likes · 18 min read
Designing a High‑Concurrency Ticket Spike System with Load Balancing, Redis, and Go
Architect
Architect
Oct 4, 2021 · Backend Development

Common Pitfalls and Best Practices of Redis Distributed Locks

Redis distributed locks are widely used for ensuring mutual exclusion in distributed systems, but improper implementation can cause issues such as non‑atomic operations, forgotten releases, lock stealing, high contention, re‑entrancy problems, timeout handling, and master‑slave failures; this article explains each pitfall and offers practical solutions and code examples.

JavaLock PitfallsRedis
0 likes · 21 min read
Common Pitfalls and Best Practices of Redis Distributed Locks
MaGe Linux Operations
MaGe Linux Operations
Oct 1, 2021 · Backend Development

Mastering Redis Distributed Locks: From SetNX to RedLock and Redisson

This article explores the most common Redis locking mechanisms—SetNX, RedLock, and Redisson—detailing their principles, pitfalls, and implementation nuances, including code examples, Lua scripts for atomic unlocks, and best‑practice recommendations for building reliable distributed locks in backend systems.

RedisRedissonRedlock
0 likes · 11 min read
Mastering Redis Distributed Locks: From SetNX to RedLock and Redisson
Top Architect
Top Architect
Oct 1, 2021 · Backend Development

Understanding Redis Locks: setnx, Redisson, and RedLock

This article explains how Redis locking works by detailing the setnx command, its modern usage with the SET command and PX expiration, common pitfalls, safe unlocking with unique values and Lua scripts, and introduces Redisson's lock implementations and the RedLock algorithm for distributed environments.

RedisRedissonRedlock
0 likes · 10 min read
Understanding Redis Locks: setnx, Redisson, and RedLock
Tongcheng Travel Technology Center
Tongcheng Travel Technology Center
Sep 30, 2021 · Operations

High‑Availability Architecture Design for the Integrated Membership System of Tongcheng and eLong

This article details the design and implementation of a high‑performance, highly available membership system for the merged Tongcheng‑eLong platform, covering Elasticsearch dual‑center clusters, traffic‑isolated three‑cluster architecture, deep ES optimizations, Redis caching and dual‑center clusters, MySQL dual‑center partitioning, migration strategies, and future fine‑grained flow‑control and degradation measures.

ElasticsearchMySQLRedis
0 likes · 21 min read
High‑Availability Architecture Design for the Integrated Membership System of Tongcheng and eLong
FunTester
FunTester
Sep 30, 2021 · Databases

Benchmarking Redis Map and INCR Operations with FunTester

This article demonstrates how to use the FunTester framework to benchmark Redis hash (map) and INCR commands, detailing the test design, Java code implementation, multithreaded execution, and summarizing the observed performance results.

Database BenchmarkFunTesterJava
0 likes · 6 min read
Benchmarking Redis Map and INCR Operations with FunTester
Java Architect Essentials
Java Architect Essentials
Sep 29, 2021 · Databases

Differences Among Jedis, Redisson, Lettuce and Using RedisTemplate & RedissonClient in Spring Boot

This article compares the Java Redis clients Jedis, Redisson, and Lettuce, explains their distinct features and thread‑safety, and provides detailed Spring Boot configurations and code examples for RedisTemplate, RedissonClient, and cache annotations to implement caching, distributed locks, and atomic operations.

JavaLettuceRedis
0 likes · 13 min read
Differences Among Jedis, Redisson, Lettuce and Using RedisTemplate & RedissonClient in Spring Boot
Top Architect
Top Architect
Sep 29, 2021 · Backend Development

Implementing Distributed Locks with Redis and Redisson in Spring Boot

This article explains the challenges of high‑concurrency inventory deduction, demonstrates why simple synchronized locks fail in distributed environments, and walks through multiple solutions—from basic SETNX locks to Redisson’s advanced distributed lock implementation—highlighting pitfalls, expiration handling, and trade‑offs with alternatives like Zookeeper.

CAP theoremRedisRedisson
0 likes · 15 min read
Implementing Distributed Locks with Redis and Redisson in Spring Boot
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 29, 2021 · Databases

Redis Interview Questions and Core Concepts: Data Types, Performance, Persistence, High Availability, and Common Use Cases

This article provides a comprehensive overview of Redis, covering its definition, basic and special data structures, performance optimizations, expiration and eviction policies, common application scenarios, persistence mechanisms, high‑availability architectures, distributed lock implementations, transaction handling, and related algorithms such as Redlock and Bloom filters.

CacheData StructuresRedis
0 likes · 45 min read
Redis Interview Questions and Core Concepts: Data Types, Performance, Persistence, High Availability, and Common Use Cases
IT Architects Alliance
IT Architects Alliance
Sep 28, 2021 · Backend Development

Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation

This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing strategies, Nginx weighted round‑robin configuration, local and remote stock deduction using Go and Redis, performance testing with ApacheBench, and key architectural lessons for preventing overselling and ensuring high availability.

Distributed ArchitectureGoRedis
0 likes · 18 min read
Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation
Java Interview Crash Guide
Java Interview Crash Guide
Sep 28, 2021 · Backend Development

What I Learned from 20 Java Interviews: High‑Frequency Questions and Real Experiences

The author, a senior Java developer with ten years of experience, documents a ten‑day interview marathon across 20 companies, summarizing interview processes, outcomes, and the most frequently asked technical questions on Java fundamentals, Spring, MySQL, Redis, MQ, and micro‑service architecture to help fellow developers prepare effectively.

InterviewJavaMySQL
0 likes · 18 min read
What I Learned from 20 Java Interviews: High‑Frequency Questions and Real Experiences
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 27, 2021 · Databases

Redis Usage Best Practices and Guidelines

This article presents comprehensive Redis usage standards—including key naming conventions, avoiding big keys, efficient serialization, safe command usage, data persistence strategies, and operational recommendations—to ensure high performance, memory efficiency, and reliable service under heavy traffic.

Cache ManagementCommand GuidelinesKey Naming
0 likes · 11 min read
Redis Usage Best Practices and Guidelines
macrozheng
macrozheng
Sep 27, 2021 · Databases

Unlocking Redis: 16 Real-World Use Cases to Supercharge Your Applications

This article explores sixteen practical Redis patterns—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and rankings—demonstrating how each can be implemented with simple Redis commands to enhance performance and scalability.

BitmapsRediscaching
0 likes · 9 min read
Unlocking Redis: 16 Real-World Use Cases to Supercharge Your Applications
IT Architects Alliance
IT Architects Alliance
Sep 26, 2021 · Backend Development

Mastering Delayed Tasks in Java: From Quartz to Redis and RabbitMQ

This article examines the concept of delayed tasks versus scheduled tasks, outlines their differences, and presents five practical implementation strategies—including database polling with Quartz, JDK DelayQueue, Netty’s HashedWheelTimer, Redis ZSET and keyspace notifications, and RabbitMQ delayed queues—complete with code samples, performance pros and cons, and scalability considerations.

JavaQuartzRedis
0 likes · 19 min read
Mastering Delayed Tasks in Java: From Quartz to Redis and RabbitMQ
IT Architects Alliance
IT Architects Alliance
Sep 24, 2021 · Databases

Common Redis Use Cases and Implementation Patterns

This article presents a comprehensive guide to using Redis for caching, distributed data sharing, distributed locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow relationships, and ranking, complete with code examples.

BitmapsDistributedLockMessageQueue
0 likes · 8 min read
Common Redis Use Cases and Implementation Patterns
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 24, 2021 · Backend Development

Mastering Redis: 16 Real-World Patterns for Caching, Locks, Counters, and More

This article presents sixteen practical Redis use‑cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tags, filtering, follow models, and ranking—explaining their data types, commands, and sample code.

BitMapCounterMessage Queue
0 likes · 8 min read
Mastering Redis: 16 Real-World Patterns for Caching, Locks, Counters, and More
Java Interview Crash Guide
Java Interview Crash Guide
Sep 24, 2021 · Databases

Why Redis Is More Than a Cache: From Basics to Clustering

Redis, an open‑source in‑memory data store, serves as a database, cache, and message broker, offering rich data types, persistence, replication, Sentinel, and clustering; this article walks through its evolution from simple caching to high‑availability, distributed architectures, and advanced client features.

ClusterIn-Memory DatabaseRedis
0 likes · 15 min read
Why Redis Is More Than a Cache: From Basics to Clustering
Sohu Tech Products
Sohu Tech Products
Sep 22, 2021 · Databases

Common Redis Use Cases and Implementation Patterns

This article introduces a collection of practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking—explaining their data types, commands, and sample code.

BitmapsLeaderboardRedis
0 likes · 8 min read
Common Redis Use Cases and Implementation Patterns
Laravel Tech Community
Laravel Tech Community
Sep 22, 2021 · Backend Development

Session Sharing Solutions in Distributed Environments: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie

The article explains why session sharing is critical in micro‑service and distributed deployments and presents four backend solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based centralized session storage, and cookie‑based sessions—detailing their implementations, advantages, and drawbacks.

RedisTomcatbackend
0 likes · 5 min read
Session Sharing Solutions in Distributed Environments: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 22, 2021 · Databases

Common Redis Interview Questions and Answers

This article provides a comprehensive list of typical Redis interview questions covering its features, performance, data structures, supported data types, common use cases, eviction policies, persistence methods, clustering, high‑availability mechanisms, transaction handling, and comparisons with local caches like Guava and Caffeine.

CacheClusteringData Structures
0 likes · 15 min read
Common Redis Interview Questions and Answers
Java Interview Crash Guide
Java Interview Crash Guide
Sep 22, 2021 · Databases

Boost Redis Performance: Proven Tips to Eliminate Latency Bottlenecks

This article examines the fundamental characteristics of Redis, explains why network latency often dominates performance, and presents practical optimization strategies such as using Unix IPC, multi-key commands, transactions, scripts, pipelining, avoiding slow commands, tuning persistence, adjusting OS settings, and adopting distributed architectures to achieve higher throughput and lower latency.

DatabasePerformance OptimizationRedis
0 likes · 17 min read
Boost Redis Performance: Proven Tips to Eliminate Latency Bottlenecks
Programmer DD
Programmer DD
Sep 20, 2021 · Databases

Unlock Redis: 16 Real‑World Patterns for Caching, Locks, Queues, and More

This article explores sixteen practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking—detailing data types, commands, and code snippets for each scenario.

Message QueueRediscaching
0 likes · 8 min read
Unlock Redis: 16 Real‑World Patterns for Caching, Locks, Queues, and More
Java Architect Essentials
Java Architect Essentials
Sep 17, 2021 · Backend Development

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

This article analyzes the at‑least‑once guarantee of message middleware, explains why duplicate deliveries occur, compares simple database‑based deduplication methods, explores concurrency challenges, and presents a non‑transactional, status‑driven idempotence solution using MySQL or Redis with practical code examples and limitations.

MySQLRedisRocketMQ
0 likes · 19 min read
How to Achieve Exactly‑Once Message Processing in RocketMQ Without Transactions
Baidu Geek Talk
Baidu Geek Talk
Sep 15, 2021 · Databases

DB-Engines September 2021 Database Rankings Analysis

The September 2021 DB‑Engines ranking shows longtime leaders Oracle, MySQL and Microsoft SQL Server losing hundreds of points, while MongoDB, Snowflake and ClickHouse surge in popularity, Redis and InfluxDB dominate their niches, and the report stresses that selecting a database should prioritize business needs over mere ranking.

ClickHouseDB-EnginesDatabase Rankings
0 likes · 7 min read
DB-Engines September 2021 Database Rankings Analysis
Code Ape Tech Column
Code Ape Tech Column
Sep 14, 2021 · Backend Development

Large File Upload with Chunking, Resume, and RandomAccessFile in Java

This article explains how to handle multi‑gigabyte video uploads by splitting files into chunks, using MD5 for identification, implementing resumable and instant uploads with Spring Boot and Redis, and leveraging Java's RandomAccessFile and memory‑mapped I/O for efficient merging.

ChunkingJavaRandomAccessFile
0 likes · 15 min read
Large File Upload with Chunking, Resume, and RandomAccessFile in Java
Wukong Talks Architecture
Wukong Talks Architecture
Sep 12, 2021 · Backend Development

Ensuring Consistency Between Cache and Database: Patterns and Strategies

This article explains the fundamentals of data consistency in distributed systems, compares strong, weak, and eventual consistency, describes three classic cache patterns (Cache‑Aside, Read‑Through/Write‑Through, Write‑Behind), and presents practical techniques such as delayed double delete, retry mechanisms, and binlog‑based asynchronous deletion to keep Redis caches and MySQL databases in sync.

Redisbackendcache patterns
0 likes · 10 min read
Ensuring Consistency Between Cache and Database: Patterns and Strategies
Code Ape Tech Column
Code Ape Tech Column
Sep 12, 2021 · Backend Development

Implementing Delayed Tasks in Java: Database Polling, JDK DelayQueue, Time Wheel, Redis, and RabbitMQ

This article explains the concept of delayed tasks, compares them with scheduled tasks, and presents five practical implementation strategies—including database polling with Quartz, JDK DelayQueue, Netty's time‑wheel algorithm, Redis sorted‑set and keyspace notifications, and RabbitMQ delayed queues—complete with code samples, advantages, and drawbacks.

JavaRedisbackend development
0 likes · 18 min read
Implementing Delayed Tasks in Java: Database Polling, JDK DelayQueue, Time Wheel, Redis, and RabbitMQ
Node Underground
Node Underground
Sep 10, 2021 · Backend Development

Master Distributed Task Scheduling with MidwayJS Task Component

This guide explains how to install, configure, and use the @midwayjs/task module for distributed and delayed task scheduling in Midway, covering Redis setup, code examples for cron jobs, local tasks, manual triggers, progress tracking, logging, and troubleshooting.

BullMidwayJSNode.js
0 likes · 8 min read
Master Distributed Task Scheduling with MidwayJS Task Component
IT Architects Alliance
IT Architects Alliance
Sep 9, 2021 · Databases

Redis Scaling Strategies: Partitioning, Master‑Slave, Sentinel, and Cluster

This article introduces the main Redis scaling solutions—including simple partitioning, master‑slave replication, Sentinel high‑availability, and Redis Cluster—explaining their concepts, usage patterns, advantages, and drawbacks to help developers choose the appropriate architecture for high‑traffic environments.

ClusterMaster‑SlaveRedis
0 likes · 12 min read
Redis Scaling Strategies: Partitioning, Master‑Slave, Sentinel, and Cluster
Selected Java Interview Questions
Selected Java Interview Questions
Sep 9, 2021 · Backend Development

Preventing Overselling in Flash‑Sale (SecKill) Systems with a Redis Distributed Lock

This article explains how a naïve SpringBoot SecKill implementation can cause overselling, then introduces Redis commands (SETNX, EXPIRE, GETSET) and a custom RedisLock component to achieve safe distributed locking, avoid deadlocks, and ensure accurate inventory updates during high‑concurrency flash‑sale events.

JavaRedisSeckill
0 likes · 10 min read
Preventing Overselling in Flash‑Sale (SecKill) Systems with a Redis Distributed Lock
Architecture Digest
Architecture Digest
Sep 9, 2021 · Backend Development

Design and Implementation of Delayed Task Processing in Java: Database Polling, DelayQueue, Time Wheel, Redis, and RabbitMQ

The article explains the concept of delayed tasks versus scheduled tasks and presents five practical Java implementations—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues—detailing their code, advantages, and drawbacks.

DelayQueueJavaQuartz
0 likes · 18 min read
Design and Implementation of Delayed Task Processing in Java: Database Polling, DelayQueue, Time Wheel, Redis, and RabbitMQ
Sohu Tech Products
Sohu Tech Products
Sep 8, 2021 · Backend Development

Why Client‑Side Caching Is Needed and How Redis Tracking Works

This article explains the motivation for client‑side caching, what data should be cached, and details the Redis tracking feature—including normal, broadcast, and redirect modes—while providing implementation examples and best‑practice guidelines for reducing latency and load on Redis servers.

Cache invalidationClient Side CachingRedis
0 likes · 9 min read
Why Client‑Side Caching Is Needed and How Redis Tracking Works
Architect
Architect
Sep 8, 2021 · Databases

Redis Scaling Solutions: Partitioning, Master‑Slave, Sentinel, and Cluster

This article explains how to extend Redis beyond a single instance by covering partitioning, master‑slave replication, Sentinel automatic failover, and Redis Cluster, describing their usage methods, advantages, and drawbacks for high‑traffic, high‑availability scenarios.

ClusterRedisSentinel
0 likes · 11 min read
Redis Scaling Solutions: Partitioning, Master‑Slave, Sentinel, and Cluster
YunZhu Net Technology Team
YunZhu Net Technology Team
Sep 8, 2021 · Backend Development

Design and Performance Evaluation of a Scalable Like System

This article analyzes common like‑system business scenarios, derives functional requirements, proposes three architectural solutions (Redis‑based priority queue, relational database, and a hybrid cache‑MQ‑DB design), presents detailed implementation code, and evaluates each approach with extensive performance tests to guide practical backend design choices.

KafkaMySQLRedis
0 likes · 18 min read
Design and Performance Evaluation of a Scalable Like System
Programmer DD
Programmer DD
Sep 8, 2021 · Backend Development

How to Keep Redis Cache Consistent with Database: Strategies and Pitfalls

This article examines the consistency challenges when using Redis as a cache for database data, compares three update strategies, and presents practical solutions such as delayed double‑delete, retry mechanisms, and handling cache penetration, avalanche, and thread‑safety issues in Java.

Cache ConsistencyDatabaseJava
0 likes · 18 min read
How to Keep Redis Cache Consistent with Database: Strategies and Pitfalls
NiuNiu MaTe
NiuNiu MaTe
Sep 8, 2021 · Backend Development

Mastering Distributed Locks with Redis: From Basics to RedLock

This article explains what distributed locks are, outlines their essential properties, walks through step‑by‑step Redis implementations—from simple SETNX to Lua‑based atomic operations—and discusses reliability strategies such as master‑slave failover and RedLock while highlighting the inherent limits of any distributed lock.

Lua ScriptingRedisRedlock
0 likes · 11 min read
Mastering Distributed Locks with Redis: From Basics to RedLock
Java Interview Crash Guide
Java Interview Crash Guide
Sep 8, 2021 · Backend Development

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

This article explores the challenges of storing billions of mapping records for a DMP in Redis and presents practical solutions such as eviction policies, key bucketing, hash‑map optimization, fragmentation reduction, and specialized memory allocators to achieve millisecond‑level real‑time queries.

HashMapJavaKey Bucketing
0 likes · 11 min read
How to Scale Redis for Billions of Keys: Memory‑Efficient Strategies
IT Architects Alliance
IT Architects Alliance
Sep 7, 2021 · Backend Development

Implementing Delayed Tasks: Strategies, Code Samples, and Trade‑offs

This article explains various approaches to implementing delayed tasks in backend systems, comparing database polling, Java's DelayQueue, Netty's time wheel, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues, with detailed code examples and analysis of each method's pros and cons.

JavaNettyRedis
0 likes · 17 min read
Implementing Delayed Tasks: Strategies, Code Samples, and Trade‑offs
Code Ape Tech Column
Code Ape Tech Column
Sep 7, 2021 · Databases

20 Classic Redis Interview Questions and Answers

This article compiles 20 classic Redis interview questions covering its definition, data structures, performance mechanisms, caching challenges, high‑availability setups, persistence options, distributed locking techniques, and best‑practice solutions, providing developers with comprehensive insights into Redis architecture and practical usage.

DatabaseDistributedLockInterview
0 likes · 50 min read
20 Classic Redis Interview Questions and Answers
Programmer DD
Programmer DD
Sep 5, 2021 · Backend Development

Mastering Delayed Tasks in Java: From Quartz to Redis and RabbitMQ

This article compares delayed and scheduled tasks, explains their differences, and presents five practical Java implementations—including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets, and RabbitMQ—highlighting each method's advantages and drawbacks.

JavaRedisbackend development
0 likes · 19 min read
Mastering Delayed Tasks in Java: From Quartz to Redis and RabbitMQ
Top Architect
Top Architect
Sep 4, 2021 · Backend Development

Various Implementations of Delayed Task Scheduling in Java: Quartz, DelayQueue, HashedWheelTimer, Redis, and RabbitMQ

This article compares delayed tasks with scheduled tasks and presents five practical Java implementations—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues—detailing their code, advantages, and drawbacks.

DelayQueueJavaQuartz
0 likes · 18 min read
Various Implementations of Delayed Task Scheduling in Java: Quartz, DelayQueue, HashedWheelTimer, Redis, and RabbitMQ