BestHub
Sign in
Tagged articles

Redis

3508 articles · Page 22 of 36
Java Architect Essentials
Java Architect Essentials
Jan 1, 2022 · Backend Development

Mastering Large File Uploads: Instant, Chunked, and Resumable Strategies in Java

This article explains why simple byte‑stream uploads fail for large files and introduces three robust solutions—instant (hash‑based) upload, chunked (slice) upload, and resumable upload—detailing their core logic, Redis tracking, and Java implementations using RandomAccessFile and MappedByteBuffer, plus practical code snippets.

Chunked UploadJavaMappedByteBuffer
0 likes · 13 min read
Mastering Large File Uploads: Instant, Chunked, and Resumable Strategies in Java
Java High-Performance Architecture
Java High-Performance Architecture
Dec 30, 2021 · Information Security

How to Deploy and Manage JumpServer for Secure Remote Access

This guide walks you through installing JumpServer—a bastion host solution that adds permission control, session monitoring, and audit logging to remote server access—by setting up MariaDB and Redis, configuring Docker, generating secret keys, running the JumpServer container, and configuring users, groups, assets, and permissions.

DevOpsDockerJumpServer
0 likes · 16 min read
How to Deploy and Manage JumpServer for Secure Remote Access
Top Architect
Top Architect
Dec 30, 2021 · Backend Development

High‑Performance Caching with OpenResty, Nginx, and Redis Using Lua

This article explains how to leverage OpenResty and Lua scripts to integrate Nginx with Redis for direct caching, compression, timed updates, request forwarding, and configurable URL management, thereby improving concurrency, reducing latency, and enhancing the resilience of backend web services.

LuaOpenRestyPerformance
0 likes · 7 min read
High‑Performance Caching with OpenResty, Nginx, and Redis Using Lua
Architecture Digest
Architecture Digest
Dec 30, 2021 · Operations

Step‑by‑Step Deployment of JumpServer with MariaDB, Redis, and Docker

This tutorial walks through installing MariaDB and Redis on a backend node, configuring Docker on a separate host, pulling and running the JumpServer container, and then setting up users, assets, and permissions so that operations teams can securely manage internal servers via a bastion host.

BastionHostDockerJumpServer
0 likes · 15 min read
Step‑by‑Step Deployment of JumpServer with MariaDB, Redis, and Docker
Java High-Performance Architecture
Java High-Performance Architecture
Dec 30, 2021 · Backend Development

Mastering Efficient Large File Uploads: Instant, Chunked & Resume Techniques

This guide explains how to improve large file upload performance by using instant (hash‑based) uploads, chunked (slice) uploads, and breakpoint‑resume strategies, detailing the underlying Redis state tracking, server‑side Java implementations with RandomAccessFile and MappedByteBuffer, and practical deployment considerations.

Chunked UploadJavaRedis
0 likes · 14 min read
Mastering Efficient Large File Uploads: Instant, Chunked & Resume Techniques
Code Ape Tech Column
Code Ape Tech Column
Dec 30, 2021 · Backend Development

Implementing JWT Invalidation with Redis Blacklist in Spring Cloud Gateway

This article explains how to invalidate JWT tokens during password changes, permission updates, or logout by using a Redis-backed blacklist approach in Spring Cloud Gateway, detailing the extraction of the token's jti, gateway filtering, downstream modifications, and a logout endpoint implementation.

AuthenticationJWTRedis
0 likes · 8 min read
Implementing JWT Invalidation with Redis Blacklist in Spring Cloud Gateway
Top Architect
Top Architect
Dec 27, 2021 · Backend Development

Redis Distributed Lock Implementation and Redisson Watchdog Mechanism

This article explains how to implement a Redis-based distributed lock, discusses the challenges of lock expiration, introduces automatic renewal strategies such as watchdogs, and provides detailed Redisson tryLock and renewal code examples for reliable concurrency control.

JavaRedisRedisson
0 likes · 12 min read
Redis Distributed Lock Implementation and Redisson Watchdog Mechanism
Top Architect
Top Architect
Dec 26, 2021 · Databases

Understanding Redis Lazy Free and Multi‑Threaded I/O: Architecture, Mechanisms, and Limitations

The article explains how Redis, originally a single‑threaded in‑memory cache, introduces Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking during large key deletions, describes the underlying event‑driven architecture, shows relevant source code, and discusses the benefits and constraints of these mechanisms.

Lazy FreeMultithreaded I/OPerformance
0 likes · 16 min read
Understanding Redis Lazy Free and Multi‑Threaded I/O: Architecture, Mechanisms, and Limitations
Code Ape Tech Column
Code Ape Tech Column
Dec 25, 2021 · Backend Development

Key New Features in Spring Boot 2.6.0

Spring Boot 2.6.0 introduces several important changes such as default prohibition of circular dependencies, custom sanitizing functions, automatic Redis connection‑pool activation, moved reactive session properties, Maven build‑info exclusions, WebTestClient support for MVC testing, and Log4j2 composite configuration options.

ConfigurationJavaRedis
0 likes · 5 min read
Key New Features in Spring Boot 2.6.0
Selected Java Interview Questions
Selected Java Interview Questions
Dec 24, 2021 · Backend Development

Implementing Fixed-Time Scheduled Tasks in Single-Node and Distributed Java Applications

This article explains how to implement fixed‑time scheduled tasks on a single machine using Timer and ScheduledThreadPoolExecutor, how to build a custom Redis‑based distributed scheduler with distributed locks, and compares several third‑party frameworks such as Quartz, TBSchedule, Elastic‑Job and Sature for distributed task execution.

JavaQuartzRedis
0 likes · 8 min read
Implementing Fixed-Time Scheduled Tasks in Single-Node and Distributed Java Applications
21CTO
21CTO
Dec 23, 2021 · Backend Development

Choosing the Right Message Broker for Microservices: RabbitMQ vs Kafka vs Redis

This article explains the difference between synchronous and asynchronous microservice communication, outlines the benefits of async messaging, and compares three popular message brokers—RabbitMQ, Kafka, and Redis—based on scale, persistence, and consumer patterns, offering guidance on selecting the right broker for various use cases.

KafkaRedisrabbitmq
0 likes · 8 min read
Choosing the Right Message Broker for Microservices: RabbitMQ vs Kafka vs Redis
Code Ape Tech Column
Code Ape Tech Column
Dec 23, 2021 · Operations

Overview of Redis Monitoring, Data Migration, and Cluster Management Tools

This article introduces essential Redis operational tools, covering the INFO command for real‑time monitoring, Prometheus‑based exporters, data migration utilities like Redis‑shake, consistency checking with Redis‑full‑check, and cluster management via CacheCloud, while offering practical usage tips.

CacheCloudData MigrationRedis
0 likes · 10 min read
Overview of Redis Monitoring, Data Migration, and Cluster Management Tools
IT Architects Alliance
IT Architects Alliance
Dec 20, 2021 · Backend Development

How to Build a Robust Flash‑Sale System that Handles Millions of Requests

This article examines the core challenges of flash‑sale (秒杀) systems—such as overselling, extreme concurrency, bot traffic, and database strain—and presents a comprehensive backend design that includes dedicated databases, dynamic URLs, static pages, Redis clustering, Nginx load balancing, SQL optimization, rate‑limiting, asynchronous order queues, and service degradation strategies.

Redisbackend designflash sale
0 likes · 14 min read
How to Build a Robust Flash‑Sale System that Handles Millions of Requests
21CTO
21CTO
Dec 17, 2021 · Backend Development

Mastering Cache: Benefits, Strategies, and Optimization Techniques

This article explores how caching accelerates read/write performance and reduces backend load, analyzes its benefits and costs, and presents practical strategies for cache updates, granularity control, penetration, avalanche, and hot‑key issues with concrete examples and diagrams.

Cache ConsistencyPerformance OptimizationRedis
0 likes · 14 min read
Mastering Cache: Benefits, Strategies, and Optimization Techniques
IT Architects Alliance
IT Architects Alliance
Dec 17, 2021 · Backend Development

Mastering Cache: Strategies to Boost Performance and Avoid Common Pitfalls

This article examines the benefits, costs, and design patterns of caching—including update policies, granularity control, penetration, bottom‑hole, avalanche, and hot‑key issues—while offering concrete optimization techniques and practical recommendations for building robust Redis‑MySQL cache layers.

Cache strategiesPerformance OptimizationRedis
0 likes · 15 min read
Mastering Cache: Strategies to Boost Performance and Avoid Common Pitfalls
IT Architects Alliance
IT Architects Alliance
Dec 17, 2021 · Databases

Comparison of Jedis, Redisson, and Lettuce and Their Integration with Spring Boot

This article compares the three popular Java Redis clients—Jedis, Redisson, and Lettuce—detailing their differences in threading, I/O, and feature sets, and provides comprehensive Spring Boot configuration and code examples for using StringRedisTemplate, RedissonClient, and Spring Cache annotations to implement caching and distributed locks.

JavaLettuceRedis
0 likes · 11 min read
Comparison of Jedis, Redisson, and Lettuce and Their Integration with Spring Boot
Practical DevOps Architecture
Practical DevOps Architecture
Dec 15, 2021 · Databases

Redis AOF Persistence Configuration Guide

This guide explains Redis AOF persistence settings, including default options, the three synchronization strategies (no, always, everysec), and practical recommendations such as enabling AOF on slaves for critical data while keeping masters free of persistence work.

AOFConfigurationDatabase
0 likes · 3 min read
Redis AOF Persistence Configuration Guide
Architect
Architect
Dec 15, 2021 · Backend Development

Cache Optimization Techniques and Design Strategies

This article explains how caching improves application performance and reduces backend load, and it details practical optimization methods such as benefit‑cost analysis, update policies, granularity control, penetration protection, bottomless‑hole mitigation, avalanche prevention, and hot‑key rebuild strategies, primarily using Redis.

OptimizationRedisdistributed systems
0 likes · 15 min read
Cache Optimization Techniques and Design Strategies
macrozheng
macrozheng
Dec 15, 2021 · Backend Development

Implement Distributed Locks with Spring Integration: Redis & Zookeeper Guide

Learn how to implement distributed locks in Spring-based applications using Spring Integration, covering Redlock, Apache Curator alternatives, and detailed step-by-step examples for Redis and Zookeeper backends, including configuration, code snippets, testing procedures, and troubleshooting tips for reliable lock management.

JavaRedisZookeeper
0 likes · 7 min read
Implement Distributed Locks with Spring Integration: Redis & Zookeeper Guide
IT Architects Alliance
IT Architects Alliance
Dec 15, 2021 · Databases

Comprehensive Redis Guide: Data Structures, Commands, Persistence, Performance Tuning, and Deployment Strategies

This article provides a thorough introduction to Redis, covering its core data structures and common commands, persistence options (RDB and AOF), memory‑management and eviction policies, pipelining, transactions and Lua scripting, performance optimization techniques, replication, Sentinel high‑availability, cluster sharding, and a comparison of popular Java clients.

ClusterData StructuresIn-Memory Database
0 likes · 40 min read
Comprehensive Redis Guide: Data Structures, Commands, Persistence, Performance Tuning, and Deployment Strategies
Senior Brother's Insights
Senior Brother's Insights
Dec 14, 2021 · Backend Development

Beyond Redis: When to Choose EhCache for Java In‑Process Caching

With hardware costs dropping, many default to Redis for caching, but it isn’t always optimal; this article examines EhCache—a pure‑Java, in‑process cache—covering its architecture, eviction policies, API and XML configurations, and step‑by‑step Spring Boot integration, helping you decide when to prefer it.

Cache EvictionEhcacheJava
0 likes · 15 min read
Beyond Redis: When to Choose EhCache for Java In‑Process Caching
Architecture Digest
Architecture Digest
Dec 14, 2021 · Information Security

Implementing a Dynamic IP Blacklist with Nginx, Lua, and Redis

This guide explains how to build a dynamic IP blacklist using Nginx, Lua scripts, and Redis to block malicious or unwanted requests at the server level, covering architecture choices, installation steps, configuration details, and the benefits of a lightweight, shared, and easily updatable solution.

IP blacklistRedisserver security
0 likes · 4 min read
Implementing a Dynamic IP Blacklist with Nginx, Lua, and Redis
Su San Talks Tech
Su San Talks Tech
Dec 13, 2021 · Backend Development

Why Distributed IDs Matter and 9 Efficient Generation Methods

This article explains the need for globally unique, high‑performance, and easy‑to‑integrate distributed IDs, outlines their essential characteristics, and compares nine common generation approaches—including UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu uid‑generator, Meituan Leaf, and Didi TinyID—detailing each method’s advantages and drawbacks.

Redisdistributed IDid generation
0 likes · 20 min read
Why Distributed IDs Matter and 9 Efficient Generation Methods
IT Architects Alliance
IT Architects Alliance
Dec 11, 2021 · Databases

Mastering Redis Replication and Sentinel: Solving Failover Challenges

This article examines the limitations of Redis master‑slave replication, explains how Redis Sentinel addresses those issues with monitoring, notification, and automatic failover, and provides detailed configuration commands, discovery mechanisms, and step‑by‑step failover procedures for building a highly available Redis deployment.

ConfigurationDatabaseFailover
0 likes · 12 min read
Mastering Redis Replication and Sentinel: Solving Failover Challenges
Code Ape Tech Column
Code Ape Tech Column
Dec 10, 2021 · Databases

13 Redis Performance Optimization Rules

This article presents thirteen practical Redis performance optimization rules, covering avoidance of slow commands, proper key expiration handling, data structure selection, persistence strategies, hardware considerations, pipelining, client optimization, and clustering to maximize throughput and minimize latency in high‑volume deployments.

DatabaseRedis
0 likes · 11 min read
13 Redis Performance Optimization Rules
Cloud Native Technology Community
Cloud Native Technology Community
Dec 9, 2021 · Backend Development

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

This article thoroughly examines how Redis distributed locks work, the pitfalls of simple SETNX‑based locks such as deadlocks and premature expiration, presents robust solutions using expiration, unique identifiers, Lua scripts, discusses the Redlock algorithm and its controversy, compares Zookeeper locks, and offers practical guidance for safe lock usage.

LuaRedisRedlock
0 likes · 31 min read
Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices
Sohu Tech Products
Sohu Tech Products
Dec 8, 2021 · Backend Development

Understanding Redis I/O and Thread Models: From Blocking to Multi‑Reactor Designs

This article explains Redis's high‑performance I/O architecture by tracing the evolution from blocking, non‑blocking, and multiplexed network models to various Reactor‑based thread designs, illustrating each model with Java pseudo‑code and diagrams to clarify why Redis adopts a single‑threaded Reactor with optional multi‑threaded I/O extensions.

JavaReactor patternRedis
0 likes · 19 min read
Understanding Redis I/O and Thread Models: From Blocking to Multi‑Reactor Designs
21CTO
21CTO
Dec 8, 2021 · Backend Development

What’s New in Django 4.0? Key Features and Installation Guide

Django 4.0 has been officially released, bringing built‑in Redis caching, enhanced form customization, new password hashing, default zoneinfo support, upgraded jQuery, PostgreSQL improvements, and a test runner shuffle option, with a simple pip installation command.

DjangoFormsRedis
0 likes · 3 min read
What’s New in Django 4.0? Key Features and Installation Guide
NiuNiu MaTe
NiuNiu MaTe
Dec 7, 2021 · Databases

Master‑Slave Replication in Redis: How It Works and How to Prevent Data Loss

This article explains why a single‑instance Redis can cause outages, introduces the master‑slave architecture, details the full and incremental synchronization processes, shows how to configure replication, addresses multi‑slave scaling, network interruptions, and automatic failover with Sentinel.

DatabaseMaster‑SlaveRedis
0 likes · 11 min read
Master‑Slave Replication in Redis: How It Works and How to Prevent Data Loss
Top Architect
Top Architect
Dec 5, 2021 · Backend Development

Handling Redis Cache Issues: Breakdown, Penetration, and Avalanche Strategies

This article explains how Redis cache can suffer from key expiration, eviction, and high‑concurrency problems such as cache breakdown, penetration, and avalanche, and presents practical lock‑based, filter‑based, and timing‑aware solutions to maintain backend stability and performance.

CacheCache AvalancheCache Breakdown
0 likes · 6 min read
Handling Redis Cache Issues: Breakdown, Penetration, and Avalanche Strategies
Top Architect
Top Architect
Dec 4, 2021 · Backend Development

Cache Usage Techniques and Design Solutions: Benefits, Costs, Update Strategies, Granularity, and Common Optimizations

This article explains how caching can accelerate read/write performance and reduce backend load, analyzes its benefits and costs, discusses update strategies, granularity control, and solutions for common problems such as cache penetration, empty‑hole, avalanche, and hot‑key reconstruction, providing practical guidelines for robust backend design.

Backend PerformanceCache invalidationOptimization
0 likes · 14 min read
Cache Usage Techniques and Design Solutions: Benefits, Costs, Update Strategies, Granularity, and Common Optimizations
IT Architects Alliance
IT Architects Alliance
Dec 3, 2021 · Backend Development

Design and Performance Optimization of a High‑Concurrency WebSocket Gateway (Version 2.0)

This article details the evolution from a Node.js‑based WebSocket gateway to a Go‑implemented, gRPC‑driven architecture, describing the redesign of connection handling, TLS off‑loading, socket ID generation, session management, custom Kafka headers, code‑level optimizations, and extensive performance testing that validates the new gateway’s scalability and resource efficiency.

GoKafkaPerformance
0 likes · 22 min read
Design and Performance Optimization of a High‑Concurrency WebSocket Gateway (Version 2.0)
Top Architect
Top Architect
Dec 2, 2021 · Backend Development

Design and Performance Optimization of a High‑Scale WebSocket Gateway (Version 2.0)

This article describes the architectural evolution from Gateway 1.0 to Gateway 2.0 for a high‑traffic document collaboration platform, detailing the redesign of the WebSocket layer, resource‑usage optimizations, heartbeat mechanisms, custom Kafka headers, message serialization, load‑testing results, and the operational lessons learned to support millions of concurrent connections.

GoKafkaPerformance
0 likes · 22 min read
Design and Performance Optimization of a High‑Scale WebSocket Gateway (Version 2.0)
Architecture Digest
Architecture Digest
Dec 2, 2021 · Backend Development

Design and Performance Optimization of a Million‑Scale WebSocket Gateway at Shimo Docs

This article details the redesign of Shimo Docs' WebSocket gateway—from a Node.js/Socket.IO 1.0 version to a Go‑based 2.0 architecture—covering handshake degradation, TLS memory savings, SnowFlake SocketID generation, Redis‑based session broadcasting, heartbeat tuning, custom Kafka headers, object pooling, MessagePack compression, extensive performance testing, and the resulting stability and scalability improvements for handling half‑a‑million concurrent connections.

GoKafkaRedis
0 likes · 23 min read
Design and Performance Optimization of a Million‑Scale WebSocket Gateway at Shimo Docs
Architect
Architect
Dec 1, 2021 · Backend Development

Design and Performance Optimization of a High‑Concurrency WebSocket Gateway (Version 2.0)

This article describes the evolution from a Node.js‑based WebSocket gateway to a Go‑powered, gRPC‑enabled architecture, detailing the redesign of the gateway, resource‑saving techniques, heartbeat and TLS optimizations, message‑broker choices, extensive performance testing, and the resulting improvements in CPU, memory, and scalability for millions of concurrent connections.

GoRedisperformance testing
0 likes · 25 min read
Design and Performance Optimization of a High‑Concurrency WebSocket Gateway (Version 2.0)
21CTO
21CTO
Nov 30, 2021 · Backend Development

Building a Million-Scale WebSocket Gateway: Architecture, Optimization & Performance

This article details the design, refactoring, and performance testing of a high‑traffic WebSocket gateway for Shimo Docs, covering the evolution from a Node.js Socket.IO version to a Go‑based microservice architecture, TLS memory tuning, socket ID generation, heartbeat handling, custom Kafka headers, and resource‑efficient scaling to half‑a‑million concurrent connections.

GoKafkaRedis
0 likes · 25 min read
Building a Million-Scale WebSocket Gateway: Architecture, Optimization & Performance
Programmer DD
Programmer DD
Nov 30, 2021 · Backend Development

Mastering Redis Distributed Locks with Jedis: A Hands‑On Guide

This tutorial demonstrates how to implement Redis distributed locks in Java using Jedis, covering lock creation with SETNX, expiration handling, safe unlocking via Lua scripts, and a high‑concurrency simulation of 100,000 users competing for limited stock.

JavaRedisSpring Boot
0 likes · 9 min read
Mastering Redis Distributed Locks with Jedis: A Hands‑On Guide
Architect
Architect
Nov 30, 2021 · Databases

Why Is Redis So Fast? Architecture, Data Structures, Persistence, Replication and Cluster

This article explains why Redis achieves extremely high performance by being an in‑memory key‑value store, using compact data structures, a single‑threaded command model with epoll‑based I/O multiplexing, efficient hash tables, progressive rehashing, various persistence options, master‑slave replication, Sentinel monitoring and a sharded Cluster architecture.

ClusterData StructuresIn-Memory Database
0 likes · 23 min read
Why Is Redis So Fast? Architecture, Data Structures, Persistence, Replication and Cluster
High Availability Architecture
High Availability Architecture
Nov 30, 2021 · Backend Development

Design and Performance Optimization of a Million‑Scale WebSocket Gateway

This article details the evolution from a Node.js Socket.IO gateway to a Go‑based, gRPC‑enabled WebSocket gateway that supports millions of concurrent connections, covering architecture redesign, TLS handling, socket ID generation, session management, heartbeat optimization, custom Kafka headers, code‑level refinements, and extensive performance testing results.

GoKafkaPerformance
0 likes · 21 min read
Design and Performance Optimization of a Million‑Scale WebSocket Gateway
Top Architect
Top Architect
Nov 27, 2021 · Backend Development

Design and Implementation of a High‑Concurrency Flash‑Sale (Seckill) System

The article explains the characteristics of flash‑sale scenarios, presents core design principles such as rate limiting, peak shaving, asynchronous processing and scalability, and details a complete backend and frontend architecture—including Redis‑based queueing and caching—to build a robust, high‑throughput seckill system.

RedisSeckillasynchronous processing
0 likes · 12 min read
Design and Implementation of a High‑Concurrency Flash‑Sale (Seckill) System
360 Tech Engineering
360 Tech Engineering
Nov 26, 2021 · Backend Development

Implementing a Redis Message Queue with RPUSH and BLPOP in PHP

This article explains how to build a Redis‑based message queue for high‑concurrency business scenarios using RPUSH to enqueue tasks and BLPOP to block‑wait for consumption, illustrated with a PHP cancel‑order example and detailed configuration and code snippets.

BLPOPMessage QueuePHP
0 likes · 6 min read
Implementing a Redis Message Queue with RPUSH and BLPOP in PHP
Top Architect
Top Architect
Nov 26, 2021 · Backend Development

Implementing Automatic Idempotency in Spring Boot Using Redis and Interceptors

This article demonstrates how to achieve automatic request idempotency in Spring Boot applications by leveraging Redis for token storage, custom annotations, and interceptor configuration, providing step-by-step code examples for building a Redis service, token service, custom annotation, interceptor, and testing the solution.

InterceptorJavaRedis
0 likes · 10 min read
Implementing Automatic Idempotency in Spring Boot Using Redis and Interceptors
IT Architects Alliance
IT Architects Alliance
Nov 26, 2021 · Fundamentals

Understanding Mutual Exclusion and Idempotency in Distributed Systems: Locks, Implementations, and GTIS

This article explains the challenges of mutual exclusion and idempotency in distributed environments, compares thread‑level and process‑level solutions, describes the principles and typical implementations of distributed locks (Zookeeper, Redis, Tair, Cerberus), and introduces GTIS as a reliable idempotency framework.

JavaRedisZookeeper
0 likes · 34 min read
Understanding Mutual Exclusion and Idempotency in Distributed Systems: Locks, Implementations, and GTIS
dbaplus Community
dbaplus Community
Nov 25, 2021 · Operations

How Unified Alert Convergence Can Transform Monitoring Systems

This article explains the background and challenges of legacy monitoring systems, defines key concepts such as exceptions, problems, alerts and recoveries, introduces critical metrics like MTTA and MTTR, and details the design, architecture, and core implementation of a unified alert convergence service using Redis delay queues.

Alert ConvergenceMTTAMTTR
0 likes · 19 min read
How Unified Alert Convergence Can Transform Monitoring Systems
Beike Product & Technology
Beike Product & Technology
Nov 25, 2021 · Backend Development

Implementation of Hystrix Circuit Breaker in PHP: Counter Design, Bucket Strategies, Distributed Time Sync, and Performance Evaluation

This article details the design and implementation of a Hystrix‑style circuit breaker for PHP, covering circular and fixed bucket counters, distributed time synchronization, dynamic Apollo configuration, event handling, monitoring tools, single‑node versus cluster approaches, key‑length handling, storage abstraction, and performance testing results.

HystrixPHPRedis
0 likes · 13 min read
Implementation of Hystrix Circuit Breaker in PHP: Counter Design, Bucket Strategies, Distributed Time Sync, and Performance Evaluation
Cloud Native Technology Community
Cloud Native Technology Community
Nov 25, 2021 · Databases

Why Is My Redis Slowing Down? A Complete Troubleshooting Guide

This article provides a systematic, step‑by‑step methodology for diagnosing Redis latency spikes, covering baseline performance testing, slow‑log analysis, high‑complexity commands, big‑key handling, expiration patterns, memory limits, fork overhead, huge‑page settings, AOF configurations, CPU binding, swap usage, memory fragmentation, network saturation, and practical monitoring tips.

DatabaseOptimizationPerformance
0 likes · 42 min read
Why Is My Redis Slowing Down? A Complete Troubleshooting Guide
vivo Internet Technology
vivo Internet Technology
Nov 24, 2021 · Databases

Redis I/O Model and Thread Model Deep Dive

The article thoroughly examines Redis’s high‑performance architecture, detailing the evolution from blocking to non‑blocking I/O, the Reactor pattern’s single‑ and multi‑reactor models, Redis’s I/O multiplexing thread design, and how its hybrid single‑thread core with auxiliary I/O threads mitigates bottlenecks under heavy traffic.

I/O multiplexingReactor patternRedis
0 likes · 16 min read
Redis I/O Model and Thread Model Deep Dive
Top Architect
Top Architect
Nov 23, 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 snapshotting and AOF command logging—detailing their commands, file structures, configuration options, performance trade‑offs, and rewrite processes.

AOFData durabilityPersistence
0 likes · 13 min read
Understanding Redis Persistence: RDB and AOF Mechanisms
Java Architect Essentials
Java Architect Essentials
Nov 22, 2021 · Databases

10 Best Practices for Using Redis Effectively

This article outlines ten essential Redis best‑practice tips, covering why to avoid the KEYS * command, using SCAN, interpreting INFO stats, leveraging hashes, setting key expirations, choosing eviction policies, handling errors, scaling with clusters, CPU considerations, and ensuring high availability with Sentinel.

PerformanceRedisbest practices
0 likes · 8 min read
10 Best Practices for Using Redis Effectively
IT Architects Alliance
IT Architects Alliance
Nov 22, 2021 · Backend Development

How to Serve 1 Million Users Buying 10 000 Train Tickets Simultaneously – A High‑Concurrency Architecture Walkthrough

This article analyzes the extreme‑traffic problem of Chinese train ticket sales, presents a multi‑layer load‑balancing architecture with Nginx weighted round‑robin, demonstrates Go and Redis code for local and global stock deduction, and shows benchmark results proving that a single machine can handle over 4 000 requests per second while preventing oversell and few‑sell.

GoRedisSeckill
0 likes · 20 min read
How to Serve 1 Million Users Buying 10 000 Train Tickets Simultaneously – A High‑Concurrency Architecture Walkthrough
MaGe Linux Operations
MaGe Linux Operations
Nov 19, 2021 · Databases

Essential Redis Monitoring Metrics Every Engineer Should Know

This guide outlines the key Redis monitoring metrics—including performance, memory, activity, persistence, and error indicators—provides detailed descriptions, command examples, and practical tips for using tools like redis-cli, redis-benchmark, and info commands to effectively track and troubleshoot your Redis instances.

DevOpsRedismetrics
0 likes · 7 min read
Essential Redis Monitoring Metrics Every Engineer Should Know
Java Architecture Diary
Java Architecture Diary
Nov 19, 2021 · Backend Development

What’s New in Spring Boot 2.6? Key Features and Configuration Changes

Spring Boot 2.6 introduces Cookie SameSite support, reactive session timeout, custom data‑masking rules, automatic Redis pool configuration, richer runtime Java metrics, build‑info personalization, new startup and disk metrics, enhanced Docker image building, and many deprecated properties removed or renamed, improving security and performance.

ConfigurationDockerJava
0 likes · 7 min read
What’s New in Spring Boot 2.6? Key Features and Configuration Changes
vivo Internet Technology
vivo Internet Technology
Nov 17, 2021 · Operations

Design and Architecture of a Unified Alert Convergence System for Monitoring

The paper presents a unified alert convergence system that centralizes metric calculation, detection, and alarm handling across monitoring subsystems, employing mechanisms such as convergence, claiming, silencing, escalation, and a Redis‑based delayed queue integrated via Kafka or REST to reduce alarm fatigue, improve MTTA/MTTR, and enable future AI‑driven AIOps.

Alert ConvergenceMTTAMTTR
0 likes · 18 min read
Design and Architecture of a Unified Alert Convergence System for Monitoring
Open Source Linux
Open Source Linux
Nov 16, 2021 · Databases

How to Stress Test Redis with redis-benchmark: A Quick Guide

This guide explains how to use Redis's built-in redis-benchmark tool to simulate concurrent client load, interpret key performance metrics such as request latency and throughput, and monitor server resource usage, helping operators prevent cache-related failures like penetration and avalanche after deployment.

OperationsRedisbenchmark
0 likes · 3 min read
How to Stress Test Redis with redis-benchmark: A Quick Guide
Architect
Architect
Nov 16, 2021 · Backend Development

Implementing API Idempotency with Spring Boot, Redis, and Custom Annotations

This article explains how to achieve reliable API idempotency in Spring Boot applications by using Redis for token storage, defining a custom @AutoIdempotent annotation, configuring an interceptor to enforce token checks, and providing complete Java code examples and testing steps.

InterceptorJavaRedis
0 likes · 9 min read
Implementing API Idempotency with Spring Boot, Redis, and Custom Annotations
DeWu Technology
DeWu Technology
Nov 16, 2021 · Databases

Full-Chain Load Testing: Redis Large-Key and Memory Leak Issues and Solutions

Full‑chain load testing uncovered a Redis large‑key bottleneck that saturated bandwidth, a memory‑leak caused by repeatedly registering shutdown hooks, and persistently high JVM heap usage, leading to solutions of key sharding with local caching, registering hooks only once, and adjusting heap size, physical memory, and alert thresholds.

Redisbackendload testing
0 likes · 7 min read
Full-Chain Load Testing: Redis Large-Key and Memory Leak Issues and Solutions
dbaplus Community
dbaplus Community
Nov 15, 2021 · Databases

Why Redis Cluster Slows Down After Scaling and How to Fix It

In a large‑scale Redis cluster, expanding nodes caused unexpected CPU spikes and higher latency for MGET operations, prompting a deep investigation that traced the issue to the CLUSTER SLOTS command and its handling of MOVED errors, followed by a code‑level optimization that reduced CPU usage by over 90% and cut command latency dramatically.

CPUClusterCluster Slots
0 likes · 19 min read
Why Redis Cluster Slows Down After Scaling and How to Fix It
Selected Java Interview Questions
Selected Java Interview Questions
Nov 12, 2021 · Backend Development

Implementing Rate Limiting in Java Spring Applications Using Guava, Redis, and Nginx

This article explains why rate limiting is needed for high‑traffic Java services, reviews common throttling techniques such as Hystrix, Sentinel, token‑bucket algorithms, and then provides multiple concrete implementations—including Guava RateLimiter, Redis counters, interceptor configuration, and Tomcat connector settings—complete with code samples.

GuavaJavaRedis
0 likes · 11 min read
Implementing Rate Limiting in Java Spring Applications Using Guava, Redis, and Nginx
Programmer DD
Programmer DD
Nov 11, 2021 · Databases

Understanding MySQL Auto‑Increment IDs and Their Limits

This article explains the different types of auto‑increment identifiers used by MySQL—including table primary keys, InnoDB row_id, Xid, trx_id, and thread_id—describes how they reach their maximum values, the consequences of overflow, and compares external solutions such as Redis‑based keys.

InnoDBMySQLRedis
0 likes · 8 min read
Understanding MySQL Auto‑Increment IDs and Their Limits
dbaplus Community
dbaplus Community
Nov 10, 2021 · Databases

How HuoLaLa Built a Hybrid‑Cloud Database Governance Platform

This article outlines HuoLaLa's journey from a fragmented multi‑cloud environment to a unified, platform‑driven database governance system, detailing the technical challenges, architectural decisions, key components for MySQL, Redis, Kafka, and other middleware, and the measurable stability and cost improvements achieved after a year of operation.

Database GovernanceKafkaMySQL
0 likes · 44 min read
How HuoLaLa Built a Hybrid‑Cloud Database Governance Platform
Programmer DD
Programmer DD
Nov 10, 2021 · Backend Development

Master Redis Rate Limiting: SetNX, ZSet Sliding Window, and Token Bucket

This article explains three practical Redis-based rate‑limiting techniques—using SETNX for simple counters, ZSET for a sliding‑window algorithm, and a token‑bucket implementation with List—complete with Java code examples and discussion of their advantages and drawbacks.

JavaRedisSliding Window
0 likes · 7 min read
Master Redis Rate Limiting: SetNX, ZSet Sliding Window, and Token Bucket
Programmer DD
Programmer DD
Nov 7, 2021 · Backend Development

How to Build a Distributed WebSocket Cluster with Spring Cloud and Consistent Hashing

This article walks through the challenges of multi‑user WebSocket communication in a clustered environment and presents two practical solutions—session broadcasting and a consistent‑hashing based routing—using Spring Boot, Spring Cloud Gateway, Redis, Netty, and Ribbon to achieve scalable, reliable real‑time messaging.

RedisSpring Bootconsistent hashing
0 likes · 19 min read
How to Build a Distributed WebSocket Cluster with Spring Cloud and Consistent Hashing
JavaEdge
JavaEdge
Nov 6, 2021 · Databases

Mastering Redis Architecture: From Data Models to Persistence Strategies

This article explains Redis’s overall architecture, covering its data model, supported value types, operation interfaces, memory versus disk storage choices, access pattern selection, I/O threading models, indexing mechanisms, specific CRUD logic, and persistence strategies, helping readers grasp both high‑level design and detailed implementation.

Database ArchitectureI/O DesignKV store
0 likes · 8 min read
Mastering Redis Architecture: From Data Models to Persistence Strategies
Top Architect
Top Architect
Nov 3, 2021 · Databases

Designing a Highly Available Redis Service with Sentinel

This article explains why Redis is widely used, defines high availability for Redis services, enumerates common failure scenarios, evaluates four architectural solutions—including single‑instance, master‑slave with one, two, and three Sentinel instances—and finally presents a production‑grade HA design using three Sentinels and a virtual IP.

Master‑SlaveRedisSentinel
0 likes · 12 min read
Designing a Highly Available Redis Service with Sentinel
IT Architects Alliance
IT Architects Alliance
Nov 2, 2021 · Databases

Comprehensive Redis Guide: Data Structures, Commands, Persistence, Performance Tuning, and Deployment Strategies

This article provides a thorough overview of Redis, covering its core data structures and common commands, persistence options, memory management and eviction policies, pipelining, transactions, Lua scripting, performance optimization techniques, replication with Sentinel, cluster sharding, and a comparison of popular Java clients.

ClusterPerformancePersistence
0 likes · 38 min read
Comprehensive Redis Guide: Data Structures, Commands, Persistence, Performance Tuning, and Deployment Strategies
Selected Java Interview Questions
Selected Java Interview Questions
Oct 31, 2021 · Backend Development

Interview Experiences and Technical Questions from Major Chinese Tech Companies (JD, Meituan, Alibaba, Toutiao, Kuaishou)

The author, a second‑year master's student in Java backend development, summarizes interview questions and experiences from JD, Meituan, Alibaba, Toutiao and Kuaishou, covering Java concurrency, JVM locking, Netty, Redis, MySQL/HBase, distributed systems, and several algorithm problems.

HBaseInterviewJava
0 likes · 15 min read
Interview Experiences and Technical Questions from Major Chinese Tech Companies (JD, Meituan, Alibaba, Toutiao, Kuaishou)
Top Architect
Top Architect
Oct 31, 2021 · Backend Development

Implementing a Dynamic IP Blacklist with Nginx, Lua, and Redis

This article explains how to build a dynamic IP blacklist using Nginx, Lua, and Redis, covering installation, configuration, Lua scripting, and deployment steps to reject requests from blacklisted IPs while keeping the solution lightweight and shareable across multiple servers.

IP blacklistLuaRedis
0 likes · 3 min read
Implementing a Dynamic IP Blacklist with Nginx, Lua, and Redis
IT Architects Alliance
IT Architects Alliance
Oct 30, 2021 · Backend Development

How to Prevent Cache Breakdown, Penetration, and Avalanche in High‑Traffic Systems

The article explains why cache breakdown, penetration, and avalanche occur under high concurrency, analyzes their root causes such as key expiration and eviction, and provides practical mitigation techniques including distributed locking, Bloom filters, and staggered key updates to keep services stable.

CacheCache AvalancheCache Breakdown
0 likes · 7 min read
How to Prevent Cache Breakdown, Penetration, and Avalanche in High‑Traffic Systems