BestHub
Sign in
Tagged articles
3250 articles
Page 8 of 33
Architecture & Thinking
Architecture & Thinking
Jul 19, 2024 · Backend Development

Why Modern Internet Architecture Gets Complex and How to Master Flash‑Sale Systems

The article examines why internet architectures have become increasingly complex, explains the unique challenges of flash‑sale (秒杀) business scenarios, and presents practical backend optimization techniques such as request filtering, Redis caching with atomic operations, ordered queues, data‑layer safeguards, and unit‑based isolation for global deployments.

CachingConcurrencyRedis
0 likes · 9 min read
Why Modern Internet Architecture Gets Complex and How to Master Flash‑Sale Systems
Java Backend Technology
Java Backend Technology
Jul 18, 2024 · Databases

How to Accurately Track Online Users with Redis Sorted Sets

This guide explains how to implement an online user counting feature using Redis sorted sets, covering user identification methods, the essential zadd, zrangeByScore, zremrangeByScore, and zrem commands, along with code examples and a concise summary of the overall approach.

Online UsersRedisSorted Set
0 likes · 7 min read
How to Accurately Track Online Users with Redis Sorted Sets
JD Cloud Developers
JD Cloud Developers
Jul 17, 2024 · Databases

Choosing the Right Database: MySQL, Redis, HBase, ClickHouse, MongoDB, Elasticsearch, Neo4j, Prometheus & Milvus Explained

Explore nine major database technologies—from traditional relational MySQL to NoSQL Redis, columnar HBase and ClickHouse, document-oriented MongoDB, search engine Elasticsearch, graph Neo4j, time‑series Prometheus, and vector Milvus—plus practical best‑practice guides, real‑world polyglot persistence scenarios, and recommended resources for mastering modern data storage.

ClickHouseDatabasesElasticsearch
0 likes · 50 min read
Choosing the Right Database: MySQL, Redis, HBase, ClickHouse, MongoDB, Elasticsearch, Neo4j, Prometheus & Milvus Explained
System Architect Go
System Architect Go
Jul 16, 2024 · Backend Development

Using Redis Stack for Full‑Text Search with RediSearch and JSON

This tutorial explains how to leverage Redis Stack modules—especially RediSearch and RedisJSON—to store movie data, build a searchable JSON index, and perform advanced full‑text queries, highlighting, sorting, pagination, custom tokenization, scoring, and index aliasing, with Go code examples.

FT.CREATEFull-Text SearchRediSearch
0 likes · 12 min read
Using Redis Stack for Full‑Text Search with RediSearch and JSON
Selected Java Interview Questions
Selected Java Interview Questions
Jul 15, 2024 · Backend Development

Redis Distributed Lock: Basic Implementation, Expiration, Safety Measures, and Lua Atomicity

This article explains how to implement a Redis distributed lock, covering the basic SETNX approach, adding expiration, handling lock release errors with renewal and unique identifiers, achieving atomicity via Lua scripts, and discussing the inherent challenges of network delay, process pause, and clock drift in distributed systems.

Backend DevelopmentLuaRedis
0 likes · 6 min read
Redis Distributed Lock: Basic Implementation, Expiration, Safety Measures, and Lua Atomicity
Senior Tony
Senior Tony
Jul 15, 2024 · Databases

Mastering Redis maxmemory‑policy: How LRU, LFU and Other Eviction Strategies Work

This article explains how Redis handles memory exhaustion by configuring maxmemory and maxmemory-policy, detailing each eviction strategy (noeviction, volatile‑lru, volatile‑lfu, volatile‑ttl, volatile‑random, allkeys‑lru, allkeys‑lfu, allkeys‑random), their implementation details, and the underlying approximate LRU algorithm.

DatabasesLFULRU
0 likes · 8 min read
Mastering Redis maxmemory‑policy: How LRU, LFU and Other Eviction Strategies Work
JD Tech
JD Tech
Jul 15, 2024 · Databases

A Comprehensive Overview of Nine Database Types and Polyglot Persistence Practices

This article provides an in‑depth survey of nine database categories—including relational, key‑value, columnar, document, graph, time‑series, and vector databases—detailing their architectures, advantages, disadvantages, best‑practice recommendations, typical use cases, and how they can be combined in polyglot persistence solutions.

ClickHouseDatabase TypesHBase
0 likes · 41 min read
A Comprehensive Overview of Nine Database Types and Polyglot Persistence Practices
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 15, 2024 · Backend Development

Build Custom SpringBoot Cache Annotations with Redis and AOP

This guide walks through creating a lightweight SpringBoot cache component using custom @Cacheable and @CacheEvict annotations, configuring Redis, implementing an AOP aspect to handle caching logic, and demonstrating usage with sample services and controller endpoints, while also discussing key generation and potential enhancements.

CacheCustomAnnotationsRedis
0 likes · 9 min read
Build Custom SpringBoot Cache Annotations with Redis and AOP
Java Tech Enthusiast
Java Tech Enthusiast
Jul 13, 2024 · Backend Development

Implementing Captcha Login with Spring Boot and Redis

The guide demonstrates how to build a front‑end/back‑end separated captcha login using Spring Boot, Kaptcha and Redis, showing Redis‑based captcha storage with a unique key, Base64 image delivery, and verification logic that replaces traditional session‑based approaches.

APICaptchaRedis
0 likes · 12 min read
Implementing Captcha Login with Spring Boot and Redis
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 12, 2024 · Backend Development

Master Distributed Locks in Spring Boot with Lock4j: A Complete Guide

This tutorial walks you through using the Lock4j distributed lock component in Spring Boot 3.2.5, covering its features, Maven dependencies, configuration, basic annotation usage, custom key generation, expiration settings, and advanced options like custom executors, key builders, failure strategies, and manual lock handling.

Lock4jRedisSpring Boot
0 likes · 9 min read
Master Distributed Locks in Spring Boot with Lock4j: A Complete Guide
Open Source Linux
Open Source Linux
Jul 12, 2024 · Backend Development

Preventing Redis Cache Inconsistency, Avalanche, Breakdown, and Penetration

This article explains the causes of Redis cache‑database inconsistency, cache avalanche, breakdown, and penetration, and provides practical strategies such as synchronous writes, delayed double deletion, expiration tuning, circuit breaking, rate limiting, and Bloom filters to keep systems stable.

Cache ConsistencyRediscache-avalanche
0 likes · 8 min read
Preventing Redis Cache Inconsistency, Avalanche, Breakdown, and Penetration
IT Architects Alliance
IT Architects Alliance
Jul 11, 2024 · Databases

Why Redis Is So Fast: Single‑Threaded Design, Multi‑Threaded I/O, and Performance Characteristics

This article explains how Redis achieves extremely high throughput—over 800 k QPS for simple commands and up to 1 M QPS with pipelining—through its C implementation, in‑memory data store, single‑threaded event loop, I/O multiplexing, and optional multithreaded I/O introduced in later versions.

I/O MultiplexingRedisSingle‑threaded
0 likes · 16 min read
Why Redis Is So Fast: Single‑Threaded Design, Multi‑Threaded I/O, and Performance Characteristics
Java Backend Technology
Java Backend Technology
Jul 11, 2024 · Backend Development

Master Distributed Locking in Java with Lock4j: A Complete Guide

This article introduces Lock4j, a versatile Java distributed‑lock component supporting RedisTemplate, Redisson and Zookeeper, explains its key features, shows how to add dependencies and configure Redis, details the @Lock4j annotation attributes, provides simple and advanced usage examples with code snippets, and demonstrates custom executors, key builders, failure strategies, and manual lock handling.

Lock4jRedisSpring Boot
0 likes · 6 min read
Master Distributed Locking in Java with Lock4j: A Complete Guide
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jul 11, 2024 · Backend Development

Implementing Online User Counting with Redis Sorted Sets (zset)

This article explains how to track online users by assigning each user a unique identifier, storing it in a Redis sorted set with an expiration timestamp, and using zadd, zrangeByScore, zremrangeByScore, and zrem commands together with browser fingerprinting to reliably count and clean up active sessions.

BackendFingerprintJSJavaScript
0 likes · 7 min read
Implementing Online User Counting with Redis Sorted Sets (zset)
Programmer Null's Self-Cultivation
Programmer Null's Self-Cultivation
Jul 10, 2024 · Information Security

Master Shiro Security: From Basics to CAS SSO Integration with SpringBoot

This comprehensive guide walks you through Shiro's core concepts, authentication and authorization mechanisms, various realm implementations, session management, distributed session handling with Redis, caching strategies, and step‑by‑step integration of CAS single sign‑on using SpringBoot and pac4j, complete with code samples.

CASRedisShiro
0 likes · 34 min read
Master Shiro Security: From Basics to CAS SSO Integration with SpringBoot
IT Architects Alliance
IT Architects Alliance
Jul 10, 2024 · Backend Development

Mastering Distributed Locks with Redis: From Basic SETNX to RedLock and Redisson

This article explains how to implement distributed locks using Redis, starting with a simple SETNX approach, identifying its shortcomings, and then presenting solutions such as thread‑identifiers, Lua scripts for atomicity, handling TTL with watchdogs, the RedLock algorithm, and practical usage via the Redisson Java client.

LuaRedisRedisson
0 likes · 18 min read
Mastering Distributed Locks with Redis: From Basic SETNX to RedLock and Redisson
Architect
Architect
Jul 9, 2024 · Backend Development

Mastering Distributed Locks with Redis: From Simple SETNX to RedLock and Redisson

This article explains how to implement distributed locks using Redis, starting with a basic SETNX approach, identifying its shortcomings, and then presenting robust solutions such as identifier‑based unlocking, Lua scripts for atomicity, the RedLock algorithm, and Redisson’s advanced features including a watchdog mechanism.

BackendConcurrencyRedis
0 likes · 19 min read
Mastering Distributed Locks with Redis: From Simple SETNX to RedLock and Redisson
MaGe Linux Operations
MaGe Linux Operations
Jul 9, 2024 · Databases

Why Redis Uses a Single Thread and How Multithreading Boosts Performance

Redis’s core operations run on a single thread to avoid concurrency overhead, while auxiliary tasks use extra threads; the article explains the single‑threaded model, Linux I/O multiplexing (select/epoll), Redis 6.0’s I/O thread feature, and practical configuration steps to improve throughput.

I/O MultiplexingRedisconfiguration
0 likes · 8 min read
Why Redis Uses a Single Thread and How Multithreading Boosts Performance
Wukong Talks Architecture
Wukong Talks Architecture
Jul 8, 2024 · Backend Development

Design and Evolution of Ctrip Ticket Booking System for Flash‑Sale Events

This article analyzes the challenges faced by Ctrip's ticket‑booking transaction system during high‑traffic flash‑sale events and presents a series of architectural optimizations—including Redis caching, database load mitigation, supplier‑system safeguards, and fine‑grained traffic‑control strategies—to achieve stable, consistent, and fast performance under extreme concurrency.

BackendDatabase OptimizationRedis
0 likes · 15 min read
Design and Evolution of Ctrip Ticket Booking System for Flash‑Sale Events
21CTO
21CTO
Jul 7, 2024 · Databases

Choosing the Right In‑Memory Database: Memcached vs Redis vs Aerospike

This article compares Memcached, Redis, and Aerospike across persistence, replication, performance, memory management, and use‑case scenarios to help you select the most suitable in‑memory database for high‑throughput, low‑latency applications.

AerospikeIn-Memory DatabaseMemcached
0 likes · 6 min read
Choosing the Right In‑Memory Database: Memcached vs Redis vs Aerospike
Architect
Architect
Jul 7, 2024 · Databases

Why Is Redis So Fast? Inside Its Single‑Threaded and Multithreaded Architecture

This article explains how Redis achieves tens of thousands of QPS on average hardware, breaks down the technical reasons behind its speed—including C implementation, in‑memory design, epoll‑based I/O multiplexing, and a single‑threaded event loop—while also detailing the evolution to multithreaded I/O in later versions.

Database ArchitecturePerformanceRedis
0 likes · 19 min read
Why Is Redis So Fast? Inside Its Single‑Threaded and Multithreaded Architecture
Top Architect
Top Architect
Jul 7, 2024 · Backend Development

Backend Request Debounce and Distributed Lock Implementation in Java

This article explains the concept of request debouncing, outlines ideal debounce component characteristics, identifies which API endpoints need debouncing, and provides detailed Java implementations using shared Redis cache and Redisson distributed locks, including custom annotations, key generation, and practical testing results.

DebounceRedisannotation
0 likes · 18 min read
Backend Request Debounce and Distributed Lock Implementation in Java
Architect
Architect
Jul 6, 2024 · Backend Development

Design and Implementation of Bilibili Live Ranking System

This article details the architecture, business value, configuration, storage choices, performance challenges, and future plans of Bilibili's live streaming ranking system, explaining how it uses MySQL and Redis, supports automated scoring, and handles high‑traffic read/write demands.

PerformanceRedisarchitecture
0 likes · 18 min read
Design and Implementation of Bilibili Live Ranking System
JD Tech
JD Tech
Jul 6, 2024 · Backend Development

Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade

This article details a step‑by‑step investigation of a JSF thread‑pool exhaustion error that occurred when upgrading the Redis version of JD's internal R2M distributed cache, analyzing stack traces, lock contention, ForkJoinPool behavior, and the eventual remediation steps.

ConcurrencyJSFR2M
0 likes · 7 min read
Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade
dbaplus Community
dbaplus Community
Jul 4, 2024 · Databases

How Uber Scaled Docstore with CacheFront: An Integrated Caching Solution

This article details Uber's Docstore distributed database challenges and explains the design, architecture, and implementation of CacheFront—a transparent, high‑performance caching layer that reduces latency, improves scalability, and maintains strong consistency across microservices.

CachingConsistencyDatabase Architecture
0 likes · 19 min read
How Uber Scaled Docstore with CacheFront: An Integrated Caching Solution
Top Architect
Top Architect
Jul 2, 2024 · Backend Development

Cache Preheating in Spring: Abstract Cache, Context Utility, and Implementation

This article explains the concept of cache preheating, provides an abstract cache class, a Spring ApplicationContext utility, a CommandLineRunner handler to load hot data at startup, and demonstrates a concrete NewsCache implementation with Redis integration, followed by a REST endpoint to access the cached data.

AbstractCacheRediscache preheat
0 likes · 8 min read
Cache Preheating in Spring: Abstract Cache, Context Utility, and Implementation
Java Tech Enthusiast
Java Tech Enthusiast
Jul 2, 2024 · Databases

Practical Redis Use Cases and Code Examples

This guide walks backend developers through twenty real‑world Redis use cases—from basic caching, lotteries, and like/collect features to ranking, PV/UV counting, Bloom filters, sign‑in, geo‑search, rate limiting, ID generation, distributed locks, messaging, session sharing, and more—providing Spring Boot code samples, limitations, and best‑practice advice.

Backend DevelopmentCachingData Structures
0 likes · 55 min read
Practical Redis Use Cases and Code Examples
Tencent Cloud Developer
Tencent Cloud Developer
Jul 2, 2024 · Backend Development

Mastering Backend Caching: Strategies, Types, Eviction & Common Pitfalls

An in‑depth guide to backend caching covers read‑through and cache‑aside strategies, local versus distributed caches (including Redis and Memcached), eviction algorithms such as FIFO, LRU and LFU, and tackles consistency, avalanche, penetration and breakdown issues with practical mitigation techniques.

BackendCache StrategiesCaching
0 likes · 12 min read
Mastering Backend Caching: Strategies, Types, Eviction & Common Pitfalls
Sanyou's Java Diary
Sanyou's Java Diary
Jul 1, 2024 · Backend Development

11 Ways to Implement Delayed Tasks in Java: From DelayQueue to Quartz

This article explores eleven practical methods for implementing delayed tasks in Java, covering native APIs like DelayQueue and Timer, advanced executors such as ScheduledThreadPoolExecutor, and popular messaging solutions including RocketMQ, RabbitMQ, Redis, Redisson, Netty, Hutool, and Quartz, with code demos and implementation details.

ConcurrencyDelayed TasksMessage queue
0 likes · 27 min read
11 Ways to Implement Delayed Tasks in Java: From DelayQueue to Quartz
Top Architect
Top Architect
Jun 29, 2024 · Backend Development

Backend Implementation of a SpringBoot-Based Seckill (Flash Sale) Project

This article details the design and implementation of a Java SpringBoot seckill system, covering its architecture, technology stack, double‑MD5 password encryption, distributed session management with Redis, unified exception handling, page and object caching, static page generation, memory‑flag plus Redis pre‑decrement and RabbitMQ asynchronous order processing, oversell prevention, and API rate limiting, accompanied by key code snippets.

Distributed SessionRabbitMQRedis
0 likes · 11 min read
Backend Implementation of a SpringBoot-Based Seckill (Flash Sale) Project
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 27, 2024 · Databases

Why Redis Is So Fast: Key Architectural Reasons

This article explains why Redis achieves extremely high performance, reaching up to 100,000 QPS, by leveraging its in‑memory design, I/O multiplexing, optimized data structures such as SDS, ziplist and skiplist, and a single‑threaded event loop, each detailed with examples and code.

In-MemoryPerformanceRedis
0 likes · 6 min read
Why Redis Is So Fast: Key Architectural Reasons
Top Architect
Top Architect
Jun 22, 2024 · Backend Development

Understanding Idempotency and Its Implementation with Custom Annotations in Java

This article explains the concept of idempotency, identifies which HTTP requests are naturally idempotent, discusses why idempotency is essential for retries, async callbacks, and message queues, and demonstrates a practical Java implementation using custom annotations, AOP, and Redis for token management.

AOPIdempotencyRedis
0 likes · 11 min read
Understanding Idempotency and Its Implementation with Custom Annotations in Java
Lobster Programming
Lobster Programming
Jun 19, 2024 · Backend Development

Ensuring Redis‑MySQL Consistency: Strategies and Best Practices

To maintain data consistency between Redis caches and MySQL databases, this article examines common pitfalls and presents three robust solutions—deleting cache before DB writes, updating the DB then removing cache, and implementing delete‑retry mechanisms—plus optional locking for strong consistency.

Cache ConsistencyMySQLRedis
0 likes · 6 min read
Ensuring Redis‑MySQL Consistency: Strategies and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Jun 18, 2024 · Databases

Why Redis Is So Fast: Single‑Threaded Core, Multi‑Threaded I/O and Performance Mechanics

The article explains how Redis achieves high QPS by using an in‑memory, single‑threaded event loop for simple commands, leverages I/O multiplexing (epoll/select/kqueue) and optional multi‑threaded I/O for heavy operations, and outlines its evolution from a pure reactor model to a hybrid multi‑threaded architecture.

DatabasesI/O MultiplexingRedis
0 likes · 17 min read
Why Redis Is So Fast: Single‑Threaded Core, Multi‑Threaded I/O and Performance Mechanics
Sanyou's Java Diary
Sanyou's Java Diary
Jun 17, 2024 · Backend Development

How to Keep Cache and Database Consistent? Proven Strategies and Common Pitfalls

This article explains why cache‑DB consistency is a long‑standing challenge, compares naive full‑load and delete‑cache approaches, analyzes concurrency and failure scenarios, and presents reliable solutions such as updating the database first followed by cache deletion using message queues or binlog subscriptions.

Cache ConsistencyDatabase SynchronizationRedis
0 likes · 19 min read
How to Keep Cache and Database Consistent? Proven Strategies and Common Pitfalls
Top Architect
Top Architect
Jun 17, 2024 · Backend Development

High‑Availability Architecture and Performance Optimization for a Large‑Scale Membership System

This article describes how a unified membership system serving billions of users across multiple platforms achieves high performance and high availability through dual‑center Elasticsearch clusters, traffic isolation, deep ES optimizations, Redis caching, dual‑center MySQL partitioning, seamless migration, and fine‑grained flow‑control and degradation strategies.

ElasticsearchPerformance OptimizationRedis
0 likes · 22 min read
High‑Availability Architecture and Performance Optimization for a Large‑Scale Membership System
Architect's Guide
Architect's Guide
Jun 13, 2024 · Databases

Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices

This article explains the relationship between MySQL and Redis, discusses why cache consistency is challenging, and details four cache update design patterns—delete‑then‑update, update‑then‑invalidate (Cache‑Aside), read/write‑through, and write‑behind—illustrating each with flow diagrams and practical considerations.

Backend ArchitectureCache ConsistencyCache Design Patterns
0 likes · 7 min read
Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices
php Courses
php Courses
Jun 11, 2024 · Backend Development

Using PECL for Fast PHP Extension Development

This tutorial explains how PHP developers can install PECL, search for and install extensions such as Redis, and integrate them into PHP code, while highlighting configuration steps and best practices for reliable backend development.

ExtensionPECLPHP
0 likes · 4 min read
Using PECL for Fast PHP Extension Development
Architect
Architect
Jun 10, 2024 · Backend Development

How to Build a Scalable Front‑Back‑Separated Captcha Login with Spring Boot and Redis

This article walks through the problem of traditional session‑based captcha login, compares it with a modern front‑back‑separated architecture, and provides a step‑by‑step implementation using Spring Boot, Kaptcha, and Redis, including full code snippets, configuration classes, and flow diagrams.

CaptchaFrontBackSeparationKaptcha
0 likes · 12 min read
How to Build a Scalable Front‑Back‑Separated Captcha Login with Spring Boot and Redis
Code Ape Tech Column
Code Ape Tech Column
Jun 9, 2024 · Databases

RedisInsight: Introduction, Installation, and Basic Usage Guide

This article introduces RedisInsight, outlines its key features, provides step‑by‑step instructions for installing it on Linux and via Kubernetes—including environment variable configuration and service deployment—and demonstrates basic usage through screenshots of its GUI.

CLIDatabase GUIInstallation
0 likes · 6 min read
RedisInsight: Introduction, Installation, and Basic Usage Guide
21CTO
21CTO
Jun 7, 2024 · Backend Development

Boost PHP Performance: Essential Caching Strategies Every Developer Should Know

This article explores fundamental PHP caching techniques—including OPcache, HTTP header client caching, Memcached/Redis object caching, reverse‑proxy page caching, dynamic content caching, and cache invalidation—providing code examples and practical guidance to help developers dramatically improve application performance and scalability.

CachingMemcachedOPcache
0 likes · 5 min read
Boost PHP Performance: Essential Caching Strategies Every Developer Should Know
Top Architect
Top Architect
Jun 5, 2024 · Backend Development

Implementing Interface Debounce (Anti‑duplicate Submission) in Java Backend with Redis and Redisson

This article explains how to prevent duplicate API calls in Java backend systems by using debounce techniques, shared Redis caches or Redisson distributed locks, and provides complete annotation‑based implementations with code examples, key generation strategies, and testing results to achieve idempotent interfaces.

DebounceRedisRedisson
0 likes · 16 min read
Implementing Interface Debounce (Anti‑duplicate Submission) in Java Backend with Redis and Redisson
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jun 5, 2024 · Backend Development

Design and Implementation of a Multi‑Level Cache Component Library in Go

This article explains the motivation, design principles, class diagram, and core Go code for a multi‑level cache library that supports in‑memory and distributed caches (Redis, Memcached) using adapter, builder, and responsibility‑chain patterns, and discusses cache‑database consistency strategies.

Adapter PatternCacheDesign Patterns
0 likes · 21 min read
Design and Implementation of a Multi‑Level Cache Component Library in Go
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 4, 2024 · Backend Development

Mastering Redisson Distributed Collections in Spring Boot 2.7

This article introduces Redisson as a Redis Java client and demonstrates how to use its distributed collection implementations—RMap, RSet, RList, RQueue, and various blocking queues—in Spring Boot 2.7, covering synchronous, fast, and asynchronous operations, lock binding, local caching, and event listeners.

Distributed CollectionsRedisRedisson
0 likes · 11 min read
Mastering Redisson Distributed Collections in Spring Boot 2.7
Top Architect
Top Architect
Jun 3, 2024 · Backend Development

Understanding Delay Queues and Implementing Them with JDK, RabbitMQ, Redis, and lmstfy

This article explains the concept, use cases, and common implementations of delay queues—including JDK's DelayQueue, RabbitMQ plugins, and Redis ZSet—followed by a detailed guide to installing, configuring, and using the open‑source lmstfy project, and concludes with promotional information for ChatGPT‑related services.

BackendGoMessage queue
0 likes · 14 min read
Understanding Delay Queues and Implementing Them with JDK, RabbitMQ, Redis, and lmstfy
Lobster Programming
Lobster Programming
Jun 3, 2024 · Backend Development

How to Ensure API Idempotency: Prevent Duplicate Requests in Backend Systems

Ensuring API idempotency is crucial to avoid duplicate operations like double crediting points or double payments, and this article examines common causes of repeated calls—such as rapid user clicks, retries, and message queues—and presents practical backend solutions including frontend controls, Redis setnx, token validation, unique indexes, counting, and state machines.

APIDatabaseRedis
0 likes · 7 min read
How to Ensure API Idempotency: Prevent Duplicate Requests in Backend Systems
Architect's Guide
Architect's Guide
Jun 1, 2024 · 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, implementing token generation and validation services, configuring an interceptor, and providing test cases to demonstrate the workflow.

IdempotencyInterceptorRedis
0 likes · 11 min read
Implementing API Idempotency with Spring Boot, Redis, and Custom Annotations
Architect
Architect
May 31, 2024 · Backend Development

7 Common Cache Pitfalls and How to Avoid Them

This article outlines seven typical cache problems—including cache penetration, breakdown, avalanche, large keys, hot keys, hit‑rate issues, and data inconsistency—and provides practical solutions such as parameter validation, Bloom filters, null‑value caching, locking, auto‑renewal, random expiration, high‑availability setups, compression, and cache warming to improve system reliability and performance.

CachingDistributed SystemsPerformance
0 likes · 22 min read
7 Common Cache Pitfalls and How to Avoid Them
Open Source Tech Hub
Open Source Tech Hub
May 29, 2024 · Backend Development

Building a High‑Performance Shared Cache for PHP Game Servers with Webman, Redis, and APCu

This article explains how to design and implement a fast, shared‑memory cache for a PHP‑based strategy game backend using Webman, Redis, MySQL, and APCu, covering service architecture, Redis usage, atomic operations with APCu locks, channel and list mechanisms, and practical code examples for multi‑process communication.

PHPRedisWebman
0 likes · 14 min read
Building a High‑Performance Shared Cache for PHP Game Servers with Webman, Redis, and APCu
dbaplus Community
dbaplus Community
May 27, 2024 · Backend Development

Why Cache Warm‑up Is Critical and How to Do It Effectively

The article recounts a painful production incident caused by missing cache warm‑up, explains why pre‑loading caches is essential for performance and reliability, and presents practical strategies such as gray‑scale rollout, database scanning, and ETL‑driven cache filling.

Backend EngineeringCache Warm-upETL
0 likes · 8 min read
Why Cache Warm‑up Is Critical and How to Do It Effectively
Top Architect
Top Architect
May 27, 2024 · Backend Development

Implementing High‑Concurrency Stock Deduction with MySQL, Redis, Lua Scripts and Distributed Locks

The article analyzes common inventory‑deduction scenarios, compares three approaches—single‑row MySQL, multi‑row MySQL, and Redis INCRBY—highlights the limitations of database‑based methods under heavy load, and presents a robust Redis‑Lua solution with distributed locking and Java code examples for reliable stock management.

Lua scriptingRedisjava
0 likes · 12 min read
Implementing High‑Concurrency Stock Deduction with MySQL, Redis, Lua Scripts and Distributed Locks
21CTO
21CTO
May 25, 2024 · Databases

How Pinterest Scaled Its Architecture: From Clusters to Sharding

This article examines Pinterest's evolution through four development phases, the core technologies it adopted, and how it transitioned from complex clustering to a simpler sharding architecture to achieve scalable, high‑availability data storage.

MySQLPinterestRedis
0 likes · 11 min read
How Pinterest Scaled Its Architecture: From Clusters to Sharding
MaGe Linux Operations
MaGe Linux Operations
May 25, 2024 · Databases

Redis Cluster Mastery: Step‑by‑Step Setup, Scaling, and Management Guide

This tutorial explains how Redis Cluster automatically shards data across multiple nodes, covering required TCP ports, hash‑slot sharding, master‑slave replication, consistency trade‑offs, essential configuration parameters, and step‑by‑step commands for creating, expanding, resharding, and managing a production‑grade Redis cluster.

ClusterDatabaseRedis
0 likes · 18 min read
Redis Cluster Mastery: Step‑by‑Step Setup, Scaling, and Management Guide
Programmer DD
Programmer DD
May 23, 2024 · Backend Development

Mastering High‑Concurrency Architecture: From Metrics to Read/Write Splitting and Caching

This article explains the essential elements of high‑concurrency system design—performance, availability, scalability—introduces quantitative metrics, classifies read‑heavy and write‑heavy scenarios, and details practical solutions such as database read/write separation, local and distributed caching, cache‑penetration and avalanche mitigation, and CQRS implementation for billion‑user applications.

CQRSCachingRedis
0 likes · 22 min read
Mastering High‑Concurrency Architecture: From Metrics to Read/Write Splitting and Caching
php Courses
php Courses
May 22, 2024 · Backend Development

Comprehensive Backend Development Course: Processes, Socket Programming, Nginx, FASTCGI, Byte Order, and Redis Fundamentals

This course provides an in‑depth exploration of core backend concepts, covering process fundamentals, TCP/IP socket communication, Nginx integration with PHP‑FPM via FASTCGI, host‑to‑network byte order conversion, and Redis basics, aiming to equip developers, sysadmins, and network engineers with comprehensive backend development skills.

Backend DevelopmentNetwork ProtocolsRedis
0 likes · 3 min read
Comprehensive Backend Development Course: Processes, Socket Programming, Nginx, FASTCGI, Byte Order, and Redis Fundamentals
IT Services Circle
IT Services Circle
May 20, 2024 · Backend Development

Why Redis Can Become a Performance Bottleneck and How to Avoid It

The article explains several common reasons why Redis may degrade performance—such as network latency, misuse of high‑complexity commands, the KEYS command, clustered key expirations, and big‑key operations—and provides practical mitigation techniques like batch commands, TTL randomization, and lazy deletion.

BackendRediskey management
0 likes · 8 min read
Why Redis Can Become a Performance Bottleneck and How to Avoid It
Selected Java Interview Questions
Selected Java Interview Questions
May 20, 2024 · Backend Development

Redis Utility Spring Boot Starter: Features, Usage, and Implementation Details

This article introduces a Spring Boot starter that provides a ready‑to‑use Redis utility suite—including common tools, distributed locks, message queues, delay queues, pagination queries and web helpers—explains how to add the Maven dependency, configure modules via YAML, and details the internal auto‑configuration and bean implementations for MQ and delayed messaging.

Backend DevelopmentRedisSpring Boot
0 likes · 8 min read
Redis Utility Spring Boot Starter: Features, Usage, and Implementation Details
ITPUB
ITPUB
May 19, 2024 · Databases

Why Redis Can Slow Down Your App and How to Fix It

This article explains common Redis performance pitfalls—including per‑command network latency, expensive commands like SUNION and KEYS, mass key expiration spikes, and big‑key deletions—and provides practical techniques such as MSET batching, randomizing expirations, and using UNLINK to keep your backend fast.

DatabaseOptimizationPerformance
0 likes · 8 min read
Why Redis Can Slow Down Your App and How to Fix It
Lobster Programming
Lobster Programming
May 17, 2024 · Backend Development

How to Implement Order Timeout Closure in E‑Commerce: 6 Proven Backend Solutions

This article compares six practical backend approaches—JDK DelayQueue, RocketMQ delayed messages, Redis expiration, Redis Zset, a dedicated task center, and passive closure—to automatically close unpaid e‑commerce orders after a configurable timeout, outlining their advantages, drawbacks, and suitable scenarios.

RedisTask Schedulingdelayed queue
0 likes · 8 min read
How to Implement Order Timeout Closure in E‑Commerce: 6 Proven Backend Solutions
Architecture Digest
Architecture Digest
May 15, 2024 · Databases

Redis Shifts to Dual Licensing: Implications and Community Reactions

Redis announced that starting with version 7.4 it will adopt a dual‑source licensing model (RSALv2 and SSPL), moving away from its permissive BSD‑3 license, sparking widespread community backlash, discussions about cloud provider restrictions, and prompting users to consider alternative databases or forks.

DatabasesLicensingOpen Source
0 likes · 6 min read
Redis Shifts to Dual Licensing: Implications and Community Reactions
Java Architect Essentials
Java Architect Essentials
May 14, 2024 · Databases

Comprehensive Guide to RediSearch: Features, Benchmarks, Installation, and Command Usage

RediSearch, a Redis module providing full-text search and secondary indexing, is introduced with its features, performance comparisons against Elasticsearch, benchmark results for index building and query throughput, detailed installation methods, and extensive command examples for creating, querying, updating, and managing indexes.

BenchmarkCLIFull-Text Search
0 likes · 13 min read
Comprehensive Guide to RediSearch: Features, Benchmarks, Installation, and Command Usage
Bilibili Tech
Bilibili Tech
May 14, 2024 · Backend Development

Design and Implementation of Bilibili Live Ranking System

The article details Bilibili’s live ranking system, explaining how configurable ranking lists—managed via a console, stored in MySQL and cached in Redis zsets—support diverse dimensions, scoring modes, and filters to boost streamer and viewer engagement, while addressing high traffic, reliability, and future scalability plans.

MySQLRedisconfiguration
0 likes · 20 min read
Design and Implementation of Bilibili Live Ranking System
Code Ape Tech Column
Code Ape Tech Column
May 14, 2024 · Backend Development

Comprehensive Guide to Spring State Machine: Concepts, Implementation, Persistence, and Troubleshooting

This article explains the fundamentals of finite‑state machines, introduces Spring Statemachine’s core features, walks through a complete Java implementation with database schema, persistence (memory and Redis), REST APIs, exception handling, and an AOP‑based solution for reliable state transitions.

AOPPersistenceRedis
0 likes · 25 min read
Comprehensive Guide to Spring State Machine: Concepts, Implementation, Persistence, and Troubleshooting
Architect
Architect
May 13, 2024 · Backend Development

Push vs Pull: Designing a Scalable Feed Timeline with Redis and Cassandra

This article analyzes feed‑timeline architectures, compares pull‑based and push‑based models, proposes an online‑push/offline‑pull hybrid, and details practical implementations using Redis SortedSets, multi‑level caching with Cassandra, cursor‑based pagination, and large‑scale push task sharding.

BackendCachingRedis
0 likes · 15 min read
Push vs Pull: Designing a Scalable Feed Timeline with Redis and Cassandra
Architect
Architect
May 11, 2024 · Backend Development

7 Common Cache Pitfalls and Practical Solutions

This article systematically examines seven typical cache problems—penetration, breakdown, avalanche, data inconsistency, big‑key, hot‑key, and low hit rate—explaining their root causes, illustrating concrete scenarios with diagrams and code, and presenting step‑by‑step mitigation techniques such as parameter validation, Bloom filters, locking, auto‑renewal, random expirations, high‑availability setups, and cache warm‑up.

BackendCacheData Consistency
0 likes · 22 min read
7 Common Cache Pitfalls and Practical Solutions
High Availability Architecture
High Availability Architecture
May 11, 2024 · Databases

Understanding and Optimizing Redis Pipeline in Spring Boot with Lettuce and Redisson

This article explains the principles of Redis Pipeline, compares Lettuce and Redisson client implementations in Spring Boot, presents performance tests showing dramatic speed gains over single commands, discusses practical usage scenarios, common pitfalls, and provides detailed source code examples for both clients.

LettucePerformanceRedis
0 likes · 29 min read
Understanding and Optimizing Redis Pipeline in Spring Boot with Lettuce and Redisson
Sanyou's Java Diary
Sanyou's Java Diary
May 9, 2024 · Databases

From Single Node to Cluster: Mastering Redis Architecture Evolution

This article walks you through Redis’s architectural journey—from a simple single‑node setup, through persistence mechanisms, master‑slave replication, Sentinel‑driven automatic failover, and finally sharding with Redis Cluster—explaining each component’s purpose, trade‑offs, and how they collectively boost performance and reliability.

ClusterPersistenceRedis
0 likes · 18 min read
From Single Node to Cluster: Mastering Redis Architecture Evolution
Lobster Programming
Lobster Programming
May 7, 2024 · Backend Development

How to Build Redis-Based Delayed Queues: 3 Practical Approaches

This article explains three common methods for implementing delayed queues with Redis—using key expiration notifications, Zset with scheduled tasks, and Redisson’s RDelayedQueue—detailing their concepts, core code examples, advantages, and limitations for backend developers.

Backend DevelopmentRedisRedisson
0 likes · 5 min read
How to Build Redis-Based Delayed Queues: 3 Practical Approaches
Lobster Programming
Lobster Programming
May 6, 2024 · Backend Development

Scaling Homepage Carousel to Millions of QPS with OpenResty, Lua, Redis, and MQ

This article explains how to design a high‑QPS hotspot data caching and retrieval system for e‑commerce homepages using OpenResty, Lua, Redis, and a message queue, detailing publishing, reading processes, workflow diagrams, and a complete Lua script that can sustain tens of thousands to millions of concurrent requests.

LuaOpenRestyRedis
0 likes · 6 min read
Scaling Homepage Carousel to Millions of QPS with OpenResty, Lua, Redis, and MQ
Open Source Tech Hub
Open Source Tech Hub
May 6, 2024 · Backend Development

How to Build a Redis-Based Delayed Queue with Lua Scripts

This article explains the concept of delayed queues, compares them with scheduled tasks, outlines common business scenarios, and provides a complete Redis implementation using Sorted Sets, Lua scripts, and PHP code, including producer and consumer examples and performance considerations.

BackendMessage queuePHP
0 likes · 17 min read
How to Build a Redis-Based Delayed Queue with Lua Scripts
Architect
Architect
May 6, 2024 · Backend Development

Designing Effective Multi‑Level Cache Architecture for Microservices

This article explains how to build a multi‑level caching system for microservice applications, covering client‑side HTTP caching, CDN and Nginx static‑resource caching, in‑process and distributed Redis caches, consistency challenges, and practical guidelines for when such a design is beneficial.

BackendCDNCaching
0 likes · 16 min read
Designing Effective Multi‑Level Cache Architecture for Microservices
MaGe Linux Operations
MaGe Linux Operations
May 4, 2024 · Databases

Unlocking Redis Memory: How Its Internal Model Impacts Performance

This article explains Redis's memory model—including memory statistics, allocation, internal data structures, object types, and encoding—while showing practical examples for estimating usage, optimizing consumption, and troubleshooting fragmentation in high‑concurrency environments.

Data StructuresOptimizationRedis
0 likes · 34 min read
Unlocking Redis Memory: How Its Internal Model Impacts Performance
Su San Talks Tech
Su San Talks Tech
May 1, 2024 · Backend Development

7 Common Cache Pitfalls and How to Avoid Them in Backend Systems

This article outlines seven typical cache issues—including cache penetration, breakdown, avalanche, data inconsistency, large keys, hot keys, and low hit rates—explains their causes, and provides practical solutions such as parameter validation, Bloom filters, locking, expiration randomization, key sharding, and cache warming to improve system reliability and performance.

BackendCacheDistributed Systems
0 likes · 20 min read
7 Common Cache Pitfalls and How to Avoid Them in Backend Systems
Top Architect
Top Architect
Apr 26, 2024 · Backend Development

Netty TCP Client Demo: Architecture Overview, Code Walkthrough, and Testing

This article presents a complete Netty TCP client demo for an IoT project, explaining the project background, architecture, modules, business flow, and detailed Java code—including a local queue, thread pool, client initialization, handler logic, and test controllers—along with deployment notes and source links.

NettyRedisSpring Boot
0 likes · 22 min read
Netty TCP Client Demo: Architecture Overview, Code Walkthrough, and Testing
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 25, 2024 · Databases

Redis Cluster: Architecture, Setup, Testing, and High Availability

This article explains Redis Cluster's sharding architecture, demonstrates how to configure multiple Redis nodes on different ports, shows commands for creating and testing the cluster, and illustrates failover behavior, highlighting its scalability and high‑availability advantages over Sentinel mode for large‑scale data workloads.

ClusterDatabaseRedis
0 likes · 11 min read
Redis Cluster: Architecture, Setup, Testing, and High Availability
IT Services Circle
IT Services Circle
Apr 25, 2024 · Backend Development

How Redisson Implements Distributed Locks Using Redis

This article explains how Redisson leverages Redis to implement distributed locks, detailing the underlying Lua scripts, lock acquisition and release processes, the watch‑dog mechanism for automatic lease renewal, and provides Java code examples for integrating and testing the lock functionality.

ConcurrencyDistributedLockLua
0 likes · 19 min read
How Redisson Implements Distributed Locks Using Redis
Architect's Guide
Architect's Guide
Apr 24, 2024 · Databases

Redis Overview: Features, Data Types, Caching Strategies, Performance, Eviction Policies, Persistence, Replication, and Sentinel

This article provides a comprehensive introduction to Redis, covering its core features, supported data types, common caching use cases in Spring Boot, typical cache‑related problems such as consistency, avalanche, penetration and breakdown, as well as performance reasons, eviction policies, persistence mechanisms, master‑slave replication, and Sentinel high‑availability architecture.

CachingDatabasePerformance
0 likes · 12 min read
Redis Overview: Features, Data Types, Caching Strategies, Performance, Eviction Policies, Persistence, Replication, and Sentinel
High Availability Architecture
High Availability Architecture
Apr 22, 2024 · Backend Development

Debugging Redis Lettuce Timeout Issues in a Spring Cloud Backend

An in‑depth investigation of a Redis timeout problem in a Spring Cloud backend reveals that the Lettuce client’s Netty EventLoop threads become blocked by synchronous Pub/Sub callbacks, causing socket buffer buildup, and proposes solutions such as increasing I/O threads or off‑loading processing to avoid the issue.

LettuceNettyRedis
0 likes · 15 min read
Debugging Redis Lettuce Timeout Issues in a Spring Cloud Backend
iQIYI Technical Product Team
iQIYI Technical Product Team
Apr 19, 2024 · Databases

Root Cause Analysis of Redis Timeout in a Spring Cloud Service Using Lettuce and Netty

A Docker image upgrade reduced Netty EventLoop threads, causing a Pub/Sub listener’s blocking Future.get() to stall one thread, fill a Redis cluster connection’s receive buffer and trigger widespread Redis timeouts in the custom Lettuce cache framework, which were eliminated by increasing I/O threads or making the callback asynchronous.

DebuggingDockerEventLoop
0 likes · 15 min read
Root Cause Analysis of Redis Timeout in a Spring Cloud Service Using Lettuce and Netty