BestHub
Sign in
Tagged articles

Redis

3508 articles · Page 8 of 36
Cognitive Technology Team
Cognitive Technology Team
Feb 27, 2025 · Backend Development

High‑Concurrency Seckill Solutions: Redis + MQ, Pressure Distribution, and Inventory Hint Techniques

This article examines common industry practices for handling massive e‑commerce flash‑sale traffic, detailing pressure‑distribution, Redis + MySQL, Redis + MQ, and Alibaba's Inventory Hint approaches, and explains how Lua scripts, transactional MQ messages, and database hints together ensure atomic stock deduction and consistency under extreme load.

Inventory HintMQRedis
0 likes · 13 min read
High‑Concurrency Seckill Solutions: Redis + MQ, Pressure Distribution, and Inventory Hint Techniques
Java Architect Essentials
Java Architect Essentials
Feb 27, 2025 · Backend Development

How to Enforce Login Attempt Limits with Spring Boot, Redis, and Lua Scripts

This article walks through the problem of locking out users after multiple failed login attempts, explains why IP‑based locking with Redis and Lua scripts is effective, and provides a complete Spring Boot implementation—including front‑end HTML, custom annotations, AOP aspect, Redis configuration, and sample controller code—to enforce a configurable login‑attempt limit.

JavaLogin Rate LimitingLua
0 likes · 18 min read
How to Enforce Login Attempt Limits with Spring Boot, Redis, and Lua Scripts
vivo Internet Technology
vivo Internet Technology
Feb 26, 2025 · Backend Development

Building a Million-User Group Chat System: Server-Side Architecture and Implementation

The article details how to engineer a Web‑based group chat that supports one million members by selecting WebSocket for real‑time communication, using read‑diffusion storage, a three‑layer architecture with Redis routing and Kafka queues, ensuring ordered, reliable delivery via TCP, ACKs and UUID deduplication, calculating unread counts with Redis ZSETs, and handling massive traffic through rate‑limiting, protobuf compression and message chunking.

Distributed ArchitectureIM SystemMessage Ordering
0 likes · 21 min read
Building a Million-User Group Chat System: Server-Side Architecture and Implementation
Bilibili Tech
Bilibili Tech
Feb 25, 2025 · Artificial Intelligence

Design and Implementation of a Live Streaming Highlight System with AI Optimization

The paper details a live‑streaming highlight system that integrates heterogeneous data sources, uses a three‑stage pipeline with MySQL/Redis storage, applies sliding‑window interval optimization and AI‑driven title generation, scoring, and segment selection, managed by a shared state‑machine, and outlines future stability and observability improvements.

Data ProcessingHighlight SystemMySQL
0 likes · 22 min read
Design and Implementation of a Live Streaming Highlight System with AI Optimization
macrozheng
macrozheng
Feb 25, 2025 · Databases

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

This guide explores 16 practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tags, filtering, follow models, and ranking—providing code snippets and implementation tips for each pattern.

BitmapsRedisdistributed lock
0 likes · 9 min read
Master Redis: 16 Real-World Patterns for Caching, Locks, and More
MaGe Linux Operations
MaGe Linux Operations
Feb 23, 2025 · Databases

Master Redis Cluster Setup: High Availability, Configuration, and Java Integration

This guide walks through why Redis clustering is needed for high availability, explains the decentralized cluster architecture introduced in Redis 3.0, provides step‑by‑step configuration of multiple redis.conf files, demonstrates creating a six‑node cluster, shows key slot calculations, fault‑tolerance handling, and includes Java Jedis code for connecting to the cluster.

ClusterJava JedisRedis
0 likes · 19 min read
Master Redis Cluster Setup: High Availability, Configuration, and Java Integration
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Feb 21, 2025 · Databases

Why Redis’s In-Memory Architecture Beats Disk: Speed, Events, and Data Structures

Redis stores data directly in memory rather than on disk, leveraging microsecond‑level access, a single‑threaded Reactor event loop with I/O multiplexing, optimized data structures like strings, hashes, lists, sets, and a simple text protocol, all of which combine to deliver exceptionally high performance for high‑frequency read/write workloads.

Data StructuresIn-Memory DatabasePerformance
0 likes · 3 min read
Why Redis’s In-Memory Architecture Beats Disk: Speed, Events, and Data Structures
Sanyou's Java Diary
Sanyou's Java Diary
Feb 20, 2025 · Databases

How Redis Sentinel Ensures Automatic Failover and High Availability

Redis Sentinel provides a robust high‑availability solution by monitoring master‑slave clusters, automatically detecting failures, electing leaders, and performing failover, while using quorum voting, Pub/Sub communication, and configuration provisioning to ensure seamless master promotion and client redirection without manual intervention.

DatabaseFailoverRedis
0 likes · 16 min read
How Redis Sentinel Ensures Automatic Failover and High Availability
Sohu Tech Products
Sohu Tech Products
Feb 19, 2025 · Backend Development

Using Apache Commons Pool for Object Pooling and Jedis Connection Pool in Java

The article explains how to use Apache Commons Pool to create reusable object pools in Java—showing Maven setup, a custom PooledObjectFactory, pool configuration, borrowing and returning objects, and demonstrates a Redis Jedis connection pool built on the same framework while detailing the pool’s initialization, borrowing, and return mechanisms.

JavaRedisapache-commons-pool
0 likes · 8 min read
Using Apache Commons Pool for Object Pooling and Jedis Connection Pool in Java
Zhuanzhuan Tech
Zhuanzhuan Tech
Feb 19, 2025 · Backend Development

High-Concurrency Flash Sale Solutions: Pressure Distribution, Redis + MQ, and Inventory Hint Techniques

This article examines common industry approaches for handling massive flash‑sale traffic, detailing pressure‑distribution sharding, Redis + MQ integration, the Inventory Hint optimization, and provides concrete Lua script examples and transactional‑message workflows for reliable stock deduction.

Inventory HintLua ScriptMessage Queue
0 likes · 12 min read
High-Concurrency Flash Sale Solutions: Pressure Distribution, Redis + MQ, and Inventory Hint Techniques
ITPUB
ITPUB
Feb 14, 2025 · Databases

Why Did Redis Crash at 100% Memory? Deep Dive into Buffer Overflows and Mitigation

An incident where massive key traffic pushed Redis memory usage to 100% revealed that buffer memory, not the dataset itself, exhausted the instance, leading to timeouts and crashes; the analysis explains the root causes, shows detailed INFO MEMORY output, and provides practical mitigation guidelines.

CacheKey DesignMemory Management
0 likes · 25 min read
Why Did Redis Crash at 100% Memory? Deep Dive into Buffer Overflows and Mitigation
dbaplus Community
dbaplus Community
Feb 13, 2025 · Databases

Automating Redis Resource Balancing to Cut DBA Effort

To handle growing memory pressure across thousands of Redis servers, the platform implements an automated, daily resource‑balancing scheduler that selects overloaded hosts, chooses optimal nodes based on instance count, tier, and placement rules, then safely migrates them through a multi‑step process with rigorous validation.

AutomationCluster ManagementRedis
0 likes · 14 min read
Automating Redis Resource Balancing to Cut DBA Effort
macrozheng
macrozheng
Feb 11, 2025 · Backend Development

Unlock Redis Performance: Using Lua Scripts in Spring Boot Applications

This comprehensive guide explains how to integrate Lua scripts with Spring Boot and Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation in Java, error handling, security considerations, and best practices for optimizing distributed applications.

Lua ScriptingRedisSpring Boot
0 likes · 21 min read
Unlock Redis Performance: Using Lua Scripts in Spring Boot Applications
Ma Wei Says
Ma Wei Says
Feb 10, 2025 · Databases

How Redis Handles Expired Keys: Periodic vs Lazy Deletion Strategies

This article explains Redis's two expiration mechanisms—periodic scanning with configurable frequency and lazy deletion on client access—detailing their configurations, execution steps, performance trade‑offs, and replication pitfalls to help developers manage memory efficiently.

Lazy DeletionMemory ManagementRedis
0 likes · 5 min read
How Redis Handles Expired Keys: Periodic vs Lazy Deletion Strategies
Java Captain
Java Captain
Feb 9, 2025 · Backend Development

Using Lua Scripts in Spring Boot with Redis for Performance and Atomic Operations

This article explains how to integrate Lua scripts into Spring Boot applications with Redis, covering Lua fundamentals, advantages of Lua in Redis, practical use cases, step‑by‑step implementation in Spring Boot, performance optimizations, error handling, security considerations, and best practices for reliable backend development.

LuaPerformanceRedis
0 likes · 23 min read
Using Lua Scripts in Spring Boot with Redis for Performance and Atomic Operations
JD Retail Technology
JD Retail Technology
Feb 7, 2025 · Backend Development

Cache Big‑Key and Hot‑Key Issues: Case Study, Root‑Cause Analysis, and Mitigation Strategies

A promotional event created an oversized Redis cache entry that, combined with cache‑penetration bursts, saturated network bandwidth and caused a service outage, prompting mitigation through Protostuff serialization, gzip compression, request throttling, and enhanced monitoring, while recommending design‑time cache planning and stress testing to prevent future big‑key failures.

BigKeyCacheHotKey
0 likes · 9 min read
Cache Big‑Key and Hot‑Key Issues: Case Study, Root‑Cause Analysis, and Mitigation Strategies
macrozheng
macrozheng
Feb 6, 2025 · Databases

How KeyDB Transforms Redis into a Multi‑Threaded Database

KeyDB, a Redis fork, replaces the single‑threaded architecture with a multi‑threaded model using a main thread and worker I/O threads, SO_REUSEPORT, per‑thread connection management, fastlock spin‑lock mechanisms, and active‑replica support, enabling concurrent data access and improved performance.

Connection ManagementKeyDBRedis
0 likes · 9 min read
How KeyDB Transforms Redis into a Multi‑Threaded Database
Architect
Architect
Feb 4, 2025 · Databases

How to Detect Redis Big Keys in Real Time with Zero Code Changes

This article presents a lightweight, non‑intrusive eBPF‑based method for instantly identifying Redis big‑key operations, explains the underlying kernel and user‑space implementation, provides complete code samples, and evaluates performance before and after optimization.

GoPerformance MonitoringRedis
0 likes · 21 min read
How to Detect Redis Big Keys in Real Time with Zero Code Changes
Lobster Programming
Lobster Programming
Feb 2, 2025 · Backend Development

How to Prevent Redis Cache Avalanche, Breakdown, and Penetration

This article explains the three major Redis cache issues—cache avalanche, cache breakdown, and cache penetration—how they can overload databases, and provides practical solutions such as high‑availability deployment, appropriate key expiration, local caches, mutex locks, empty‑object caching, request validation, and Bloom filters.

CacheDatabasePerformance
0 likes · 5 min read
How to Prevent Redis Cache Avalanche, Breakdown, and Penetration
MaGe Linux Operations
MaGe Linux Operations
Jan 30, 2025 · Databases

Master Redis Data Types and Commands: Strings, Hashes, Lists, Sets, Sorted Sets

This guide provides a comprehensive overview of Redis data structures—including strings, hashes, lists, sets, and sorted sets—along with essential commands for creating, reading, updating, and deleting keys, managing expirations, and performing set operations, enabling developers to effectively leverage Redis as a high‑performance NoSQL database.

Data TypesDatabaseNoSQL
0 likes · 31 min read
Master Redis Data Types and Commands: Strings, Hashes, Lists, Sets, Sorted Sets
Code Ape Tech Column
Code Ape Tech Column
Jan 27, 2025 · Backend Development

Comprehensive Guide to Rate Limiting Strategies and Implementations in Microservice Architecture

This article systematically explains the importance of rate limiting in microservice systems, compares various governance frameworks such as Dubbo and Spring Cloud, introduces common algorithms like token‑bucket and leaky‑bucket, and provides detailed implementation examples using Guava, Sentinel, Redis+Lua, and a custom Spring Boot starter.

JavaRedisSentinel
0 likes · 25 min read
Comprehensive Guide to Rate Limiting Strategies and Implementations in Microservice Architecture
Architect
Architect
Jan 26, 2025 · Databases

Optimizing Redis Cluster Slot Migration to Reduce Latency and Improve High Availability

This article analyzes the latency and availability problems of native Redis cluster slot migration, proposes a master‑slave synchronization based redesign that batches slot transfers, reduces ask‑move and topology‑change overhead, and validates the solution with performance tests showing smoother latency and higher reliability.

ClusterRedisSlot Migration
0 likes · 16 min read
Optimizing Redis Cluster Slot Migration to Reduce Latency and Improve High Availability
Java Tech Enthusiast
Java Tech Enthusiast
Jan 24, 2025 · Databases

Why Redis Is Fast: Deep Dive into Performance Principles

Redis achieves remarkable speed by storing data entirely in memory, employing a single‑threaded event loop with I/O multiplexing, and using highly optimized in‑memory data structures while balancing durability through efficient persistence mechanisms, all of which combine to minimize latency and maximize throughput.

Data StructuresI/O multiplexingIn-Memory
0 likes · 6 min read
Why Redis Is Fast: Deep Dive into Performance Principles
Code Ape Tech Column
Code Ape Tech Column
Jan 22, 2025 · Backend Development

Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide

This article introduces Lua scripting in Redis, explains its fundamentals and advantages, and provides step‑by‑step instructions for integrating and executing Lua scripts within a Spring Boot application, including code examples, performance optimization, error handling, security considerations, and best practices.

LuaRedisSpring Boot
0 likes · 19 min read
Using Lua Scripts with Spring Boot and Redis: A Comprehensive Guide
JD Cloud Developers
JD Cloud Developers
Jan 22, 2025 · Backend Development

Mastering High-Concurrency Inventory Deduction for Flash Sale Systems

This article explores practical strategies for handling the high‑concurrency inventory deduction problem in flash‑sale scenarios, covering lock‑based approaches, Redis caching, partitioned stock management, asynchronous updates, and distributed scaling techniques to prevent overselling and improve throughput.

MySQLRedisbackend architecture
0 likes · 11 min read
Mastering High-Concurrency Inventory Deduction for Flash Sale Systems
JD Cloud Developers
JD Cloud Developers
Jan 20, 2025 · Backend Development

Boosting Inventory Reservation Performance: Strategies for High‑Concurrency Scenarios

This article examines the core challenges of high‑concurrency inventory pre‑reservation, evaluates async throttling, horizontal stock splitting, and Redis‑based write‑shielding, and presents concrete implementations, performance results, thread‑safety techniques, deadlock avoidance, and data‑consistency safeguards for robust backend systems.

InventoryMySQLPerformance Optimization
0 likes · 11 min read
Boosting Inventory Reservation Performance: Strategies for High‑Concurrency Scenarios
Lobster Programming
Lobster Programming
Jan 20, 2025 · Backend Development

Boost High‑Concurrency Performance: When to Use Redis vs. Local Cache

This article explains why traditional relational databases falter under high‑concurrency loads, introduces caching as a solution, compares Redis distributed caching with local in‑process caching, and shows how combining them into a multi‑level cache can dramatically improve performance and reliability.

Rediscachingdistributed cache
0 likes · 5 min read
Boost High‑Concurrency Performance: When to Use Redis vs. Local Cache
MaGe Linux Operations
MaGe Linux Operations
Jan 17, 2025 · Databases

Understanding Redis Cluster: Architecture, Data Distribution, and Fault Tolerance

Redis Cluster provides a scalable, fault‑tolerant distributed Redis solution, explaining why it’s needed, its architecture, virtual slot partitioning, data distribution methods, limitations, smart client optimization, and automatic failover mechanisms, while highlighting key operational considerations for high‑performance deployments.

ClusterRedisVirtual Slots
0 likes · 11 min read
Understanding Redis Cluster: Architecture, Data Distribution, and Fault Tolerance
JD Tech Talk
JD Tech Talk
Jan 17, 2025 · Backend Development

Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade

During a Redis version upgrade of the internal R2M cache service, a Biz thread‑pool exhaustion error was traced to JSF threads blocked on a read lock held by a topology‑updater task, revealing a deadlock caused by shared ForkJoinPool usage and missing lock timeouts.

JSFJavaRedis
0 likes · 5 min read
Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade
Go Programming World
Go Programming World
Jan 17, 2025 · Backend Development

A Quick Guide to Go's os/exec Package: Running External Commands and Real‑World Use Cases

This article introduces Go's built‑in os/exec package, explains its exported types and methods, demonstrates how to run commands synchronously or in the background, capture output, handle pipes, environment variables, working directories, and shows a practical case study using the tempredis library to start a Redis server programmatically.

GoProcess ManagementRedis
0 likes · 21 min read
A Quick Guide to Go's os/exec Package: Running External Commands and Real‑World Use Cases
vivo Internet Technology
vivo Internet Technology
Jan 15, 2025 · Databases

Redis Persistence Mechanisms: AOF, RDB, and Hybrid Persistence

Redis offers three persistence options—Append‑Only File (AOF) which logs every write, RDB snapshots that capture point‑in‑time data, and a hybrid mode combining both—each configurable with trade‑offs in durability, recovery speed, file size, and performance to suit different application needs.

AOFDatabasePersistence
0 likes · 21 min read
Redis Persistence Mechanisms: AOF, RDB, and Hybrid Persistence
Test Development Learning Exchange
Test Development Learning Exchange
Jan 14, 2025 · Backend Development

Building a Secure and Efficient Online Webpage Screenshot Service with Flask, Selenium, and Redis

This guide demonstrates how to create a robust online webpage screenshot service using Python, Selenium, and Flask, incorporating security measures like CSRF protection and domain whitelisting, performance enhancements with Redis caching and rate limiting, comprehensive error handling, resource management, and extensibility for future features.

FlaskPythonRedis
0 likes · 6 min read
Building a Secure and Efficient Online Webpage Screenshot Service with Flask, Selenium, and Redis
Java Architect Essentials
Java Architect Essentials
Jan 14, 2025 · Databases

Implementing Online User Counting with Redis Sorted Sets (ZSET)

This article explains how to track online users by storing their identifiers in a Redis sorted set, using expiration timestamps as scores, and demonstrates adding, querying, and cleaning up entries with ZADD, ZRANGEBYSCORE, ZREMRANGEBYSCORE, and ZREM commands in both Java and JavaScript.

JavaJavaScriptRedis
0 likes · 7 min read
Implementing Online User Counting with Redis Sorted Sets (ZSET)
Test Development Learning Exchange
Test Development Learning Exchange
Jan 13, 2025 · Backend Development

Building a Python Flask Service for Automatic ID Generation

This guide demonstrates how to build a Python Flask-based RESTful service that generates various types of unique identifiers—including UUIDs, timestamps, Redis counters, Snowflake IDs, and random strings—while covering installation, code implementation, API endpoints, error handling, rate limiting, and extensibility considerations.

APIFlaskPython
0 likes · 7 min read
Building a Python Flask Service for Automatic ID Generation
Top Architecture Tech Stack
Top Architecture Tech Stack
Jan 13, 2025 · Databases

Using Multithreading in Redis: I/O Threads, Background Tasks, and Memory Allocator

The article explains how Redis, a high‑performance key‑value store, can leverage multithreading for I/O operations, background tasks like UNLINK, and jemalloc memory‑management threads, providing configuration examples and Python code to improve performance in high‑concurrency scenarios while noting the associated CPU cost.

I/O ThreadsMemory ManagementPython
0 likes · 6 min read
Using Multithreading in Redis: I/O Threads, Background Tasks, and Memory Allocator
DaTaobao Tech
DaTaobao Tech
Jan 10, 2025 · Artificial Intelligence

AI-Driven Efficiency Improvements in a Chatroom Project

The article shows how AI accelerated a chatroom project's development—cutting cycle time, lowering developer skill demands, and delivering over 8% efficiency gains—by auto‑generating boilerplate code, debugging suggestions, and routine components such as API, Redis, MySQL, and WebSocket snippets, while outlining future improvements and a potential additional 10% R&D boost through integrated AI tools.

AIPythonRedis
0 likes · 9 min read
AI-Driven Efficiency Improvements in a Chatroom Project
Top Architect
Top Architect
Jan 8, 2025 · Backend Development

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

This article demonstrates how to build a dynamic IP blacklist using Nginx, Lua scripts, and Redis, covering requirements, environment setup, design options, nginx.conf configuration, detailed Lua code, summary of advantages, and extensions such as use cases and advanced features.

IP blacklistLuaRedis
0 likes · 11 min read
Implementing a Dynamic IP Blacklist with Nginx, Lua, and Redis
Aikesheng Open Source Community
Aikesheng Open Source Community
Jan 7, 2025 · Databases

Analysis of Redis Sentinel Failover Issue in Redis 7.4.0 and Resolution via Pub/Sub ACL Adjustment

This article investigates a Redis Sentinel failover anomaly in version 7.4.0 where the sentinel repeatedly elects a failed master, explains the underlying s_down/o_down states, examines network, configuration, and ACL settings, and resolves the issue by adjusting Pub/Sub permissions to allow proper failover.

ACLDatabaseFailover
0 likes · 11 min read
Analysis of Redis Sentinel Failover Issue in Redis 7.4.0 and Resolution via Pub/Sub ACL Adjustment
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 7, 2025 · Backend Development

Cache Consistency: Pitfalls of Delayed Double Delete and Lease/Versioning Solutions with Redis

This article examines why many large‑scale systems avoid the traditional delayed double‑delete cache‑invalidation strategy, explains its critical drawbacks, and presents alternative lease‑based and version‑based approaches with Lua scripts and Java wrappers for Redis to achieve stronger consistency.

Delayed Double DeleteJavaLua
0 likes · 17 min read
Cache Consistency: Pitfalls of Delayed Double Delete and Lease/Versioning Solutions with Redis
Architect
Architect
Jan 5, 2025 · Information Security

How to Build a Dynamic IP Blacklist with Nginx, Lua, and Redis

This guide explains how to create a dynamic IP blacklist that blocks malicious crawlers or users by configuring Nginx with Lua scripts and a Redis store, covering requirements, environment setup, design choices, configuration files, Lua code, and advanced usage scenarios.

IP blacklistLuaRedis
0 likes · 9 min read
How to Build a Dynamic IP Blacklist with Nginx, Lua, and Redis
Java Tech Enthusiast
Java Tech Enthusiast
Jan 4, 2025 · Databases

Understanding Redis Sets and Their Use Cases

Redis Sets are unordered collections of unique strings backed by hash tables that provide O(1) add, delete, and lookup operations, automatically switch to a compact integer array (intset) for small integer-only sets, and are ideal for deduplicated data and fast set operations such as intersection, union, and difference, exemplified by computing common friends in social applications.

Code ExampleDatabaseRedis
0 likes · 4 min read
Understanding Redis Sets and Their Use Cases
dbaplus Community
dbaplus Community
Jan 2, 2025 · Databases

Why the Redis KEYS Command Is Dangerous and How to Replace It

The article explains that Redis's KEYS command scans all keys, blocks the server for seconds, can trigger failover issues, and provides faster alternatives like SCAN or storing keys in a set, while also showing how KEYS works in a Redis Cluster and its real‑world latency measurements.

ClusterKEYS commandPerformance
0 likes · 5 min read
Why the Redis KEYS Command Is Dangerous and How to Replace It
Architect
Architect
Dec 30, 2024 · Backend Development

How to Speed Up Legacy Report Queries with Redis Archiving and Scheduled Tasks

This article details how a legacy reporting module suffering from slow page loads was refactored by archiving log data, caching hourly counts in Redis, and using scheduled synchronization to dramatically improve query performance without adding new middleware.

JavaKafkaPerformance Optimization
0 likes · 11 min read
How to Speed Up Legacy Report Queries with Redis Archiving and Scheduled Tasks
macrozheng
macrozheng
Dec 27, 2024 · Backend Development

Unlock Shopee Backend Interview Secrets: Core Concepts & Practical Tips

This article breaks down Shopee's backend interview experience, covering salary offers, location details, interview difficulty, and a comprehensive review of essential topics such as network protocols, rate‑limiting algorithms, Java thread pools, Redis eviction and expiration strategies, MySQL isolation levels, index structures, MVCC, slow‑query optimization, redo vs binlog, and RocketMQ distributed transaction, ordering, and backlog handling, while also linking to useful open‑source projects and video tutorials.

InterviewMySQLRedis
0 likes · 30 min read
Unlock Shopee Backend Interview Secrets: Core Concepts & Practical Tips
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 27, 2024 · Frontend Development

My Technical Stack Overview

This article presents a comprehensive overview of the author's current technology stack, covering frontend frameworks like React and Next.js, mobile development with React Native, TypeScript usage, backend tools such as NestJS, Prisma with MySQL, Redis caching, and frontend engineering practices.

NestJSNext.jsNode.js
0 likes · 11 min read
My Technical Stack Overview
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 27, 2024 · Backend Development

Master Spring Cloud Gateway: Real‑World Cases, Configurations, and Code Samples

This tutorial introduces Spring Cloud Gateway, explains its core features and Actuator integration, and provides step‑by‑step practical examples for viewing routes, global filters, route filters, refreshing routes, managing routes via REST endpoints, creating and deleting routes, and sharing routes with Redis, all accompanied by code snippets and configuration details.

API-gatewayActuatorRedis
0 likes · 11 min read
Master Spring Cloud Gateway: Real‑World Cases, Configurations, and Code Samples
Top Architect
Top Architect
Dec 26, 2024 · Backend Development

Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts

This article explains how to prevent brute‑force password attempts by locking an IP after three failed logins using a Spring Boot backend, Redis for distributed counters, and a Lua script to ensure atomic increment and expiration, while also providing a simple HTML login page for the front end.

JavaLoginRateLimitingLua
0 likes · 19 min read
Implementing Login Attempt Limiting with Spring Boot, Redis, and Lua Scripts
Efficient Ops
Efficient Ops
Dec 24, 2024 · Databases

Why Is My Redis Slowing Down? 10 Common Causes and How to Fix Them

Redis can appear slow for many reasons—including baseline latency differences, high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, CPU binding, swap usage, memory fragmentation, and AOF configuration—so this guide explains each cause, how to diagnose it, and practical optimization steps.

Memory ManagementPerformance TuningRedis
0 likes · 34 min read
Why Is My Redis Slowing Down? 10 Common Causes and How to Fix Them
Architect
Architect
Dec 22, 2024 · Backend Development

Implementing Interface Debounce with Distributed Locks in Java (Redis & Redisson)

This article explains the concept of request debouncing, identifies which API endpoints need it, and provides a detailed tutorial on implementing distributed debounce using shared Redis cache or Redisson locks in a Spring Boot backend, complete with annotation design, unique key generation, and code examples.

JavaRedisRedisson
0 likes · 16 min read
Implementing Interface Debounce with Distributed Locks in Java (Redis & Redisson)
IT Services Circle
IT Services Circle
Dec 20, 2024 · Backend Development

Comprehensive Backend Development Interview Notes: OS Memory, Concurrency, Networking, Databases, Redis, Kafka, and Docker

This article compiles detailed backend interview notes covering salary expectations, OS stack vs heap differences, process and thread concepts, DNS resolution, ping protocol, MySQL indexing and locking mechanisms, Redis performance characteristics, Kafka throughput optimizations, and Docker's underlying implementation.

DockerInterviewNetworking
0 likes · 17 min read
Comprehensive Backend Development Interview Notes: OS Memory, Concurrency, Networking, Databases, Redis, Kafka, and Docker
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 20, 2024 · Databases

11 Proven Ways to Keep Redis Lightning‑Fast and Avoid Latency

This guide presents eleven practical recommendations—including avoiding large keys, disabling costly commands, using UNLINK, enabling lazy free, batching operations, and configuring connection pools—to help developers maintain Redis performance and prevent latency spikes in production environments.

Performance OptimizationRedisSpring Boot
0 likes · 13 min read
11 Proven Ways to Keep Redis Lightning‑Fast and Avoid Latency
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 18, 2024 · Fundamentals

Understanding Bloom Filters and Their Support in Redis

This article explains the probabilistic Bloom filter data structure, its characteristics and typical use cases such as cache‑penetration prevention, details its simple implementation steps, demonstrates how Redis (via Redisson) provides built‑in Bloom filter support with Java code examples, and summarizes its practical benefits.

Bloom filterCache PenetrationJava
0 likes · 7 min read
Understanding Bloom Filters and Their Support in Redis
Architect
Architect
Dec 16, 2024 · Backend Development

How to Build a Scalable Feed Stream: Architecture, Models, and Best Practices

This article explains what a feed stream is, why it exists, how it evolved from RSS to modern social feeds, classifies different feed models, outlines the challenges of real‑time delivery, and provides a detailed backend architecture, data structures, storage design, pagination strategy, and core publish‑read workflows to help engineers build reliable, high‑performance feed systems.

Message QueuePaginationRead‑Write Diffusion
0 likes · 23 min read
How to Build a Scalable Feed Stream: Architecture, Models, and Best Practices
21CTO
21CTO
Dec 15, 2024 · Databases

Why Antirez Is Returning to Redis: Insights on Licensing, AI, and Vector Search

Redis Labs announces the return of its founder Antirez, who shares his reasons for rejoining, discusses the recent licensing shift, reflects on his past projects, and outlines future plans for AI integration, vector indexing, and community engagement within the Redis ecosystem.

AIDatabaseLicensing
0 likes · 16 min read
Why Antirez Is Returning to Redis: Insights on Licensing, AI, and Vector Search
Bilibili Tech
Bilibili Tech
Dec 13, 2024 · Databases

Design and Implementation of a Multi-Level Storage Architecture for Bilibili Comment Service

The paper proposes a multi‑level storage architecture for Bilibili’s comment service that replaces TiDB with a custom KV store (Taishan) and Redis caching, introduces unstructured indexes, CAS‑based consistency, real‑time and offline reconciliation, and a hedged degradation strategy to boost reliability, read throughput, and scalability during traffic spikes.

Data ConsistencyNoSQLRedis
0 likes · 13 min read
Design and Implementation of a Multi-Level Storage Architecture for Bilibili Comment Service
Lobster Programming
Lobster Programming
Dec 12, 2024 · Backend Development

How to Use Redis Bitmap for Efficient User Sign‑In Tracking

This article explains why storing daily sign‑in data in a traditional database can cause performance issues at scale and demonstrates how Redis bitmap, a memory‑efficient bit‑level structure, can record and compute continuous user sign‑ins both by date and by user.

BitMapData StructuresRedis
0 likes · 5 min read
How to Use Redis Bitmap for Efficient User Sign‑In Tracking
JD Cloud Developers
JD Cloud Developers
Dec 10, 2024 · Operations

How We Boosted Inventory Platform Stability 24× with Smart Traffic Splitting and Redis Caching

This article examines the stability challenges of an e‑commerce inventory platform—including workflow complexity, database hotspots, and high‑frequency calculations—and details comprehensive solutions such as traffic splitting, gray releases, Redis caching, data consistency mechanisms, rate limiting, and monitoring enhancements that together improved throughput by 24× and reduced latency dramatically.

InventoryRedisStability
0 likes · 14 min read
How We Boosted Inventory Platform Stability 24× with Smart Traffic Splitting and Redis Caching
Architect
Architect
Dec 8, 2024 · Backend Development

16 Essential Redis Patterns Every Backend Engineer Should Master

This article compiles sixteen practical Redis use‑cases—from caching and distributed locks to rate limiting, bitmaps, shopping carts, timelines, queues, likes, tags, filtering, follow/fan relationships, and leaderboards—providing code snippets and command examples to help backend developers design scalable systems.

Design PatternsRedisbackend
0 likes · 11 min read
16 Essential Redis Patterns Every Backend Engineer Should Master
Senior Tony
Senior Tony
Dec 6, 2024 · Databases

Why MySQL COUNT(*) Can Be Milliseconds Fast: Engine Tricks & Optimization Strategies

This article explains why COUNT(*) on a large InnoDB table can take seconds while MyISAM returns instantly, explores the underlying storage‑engine differences, and presents six practical techniques—including Redis counters, counting tables with transactions or triggers, parallel read threads, secondary indexes, and SHOW TABLE STATUS—to dramatically speed up row counting in MySQL.

COUNTInnoDBMySQL
0 likes · 9 min read
Why MySQL COUNT(*) Can Be Milliseconds Fast: Engine Tricks & Optimization Strategies
Lobster Programming
Lobster Programming
Dec 2, 2024 · Backend Development

Designing Scalable E‑Commerce Shopping Carts: From Cookies to Redis

This article explores the core functions of e‑commerce shopping carts and compares client‑side storage methods such as Cookies and LocalStorage with server‑side solutions like Redis and MySQL, offering guidance on choosing the appropriate approach based on business scale and reliability requirements.

E‑commerceMySQLRedis
0 likes · 7 min read
Designing Scalable E‑Commerce Shopping Carts: From Cookies to Redis
dbaplus Community
dbaplus Community
Dec 1, 2024 · Backend Development

Why Redis Expiration Listeners Fail for Delayed Tasks and Better Alternatives

This article examines why using Redis key‑space expiration notifications for delayed job execution is unreliable, compares common approaches such as message‑queue delayed delivery, RabbitMQ dead‑letter queues, time wheels, and Redisson DelayQueue, and provides practical recommendations for robust timeout handling in e‑commerce systems.

RedisTime Wheelbackend
0 likes · 7 min read
Why Redis Expiration Listeners Fail for Delayed Tasks and Better Alternatives
dbaplus Community
dbaplus Community
Nov 28, 2024 · Cloud Native

Can Redis Thrive on Kubernetes? Insights from Kuaishou’s Cloud‑Native Journey

Drawing on Kuaishou’s experience, this article examines whether stateful services like Redis belong on Kubernetes, outlines the benefits and risks, and details a cloud‑native solution using custom workloads, KubeBlocks, and a federated cluster architecture to achieve scalable, reliable Redis deployments.

Federated ClustersKubeBlocksKubernetes
0 likes · 15 min read
Can Redis Thrive on Kubernetes? Insights from Kuaishou’s Cloud‑Native Journey
vivo Internet Technology
vivo Internet Technology
Nov 27, 2024 · Backend Development

Implementation Principles of Distributed Locks with Redis and Zookeeper

Distributed locks synchronize multiple services across nodes, and can be implemented using Redis’s fast, AP‑oriented SET‑NX with automatic TTL renewal or Zookeeper’s CP‑oriented ephemeral sequential nodes, each offering distinct trade‑offs in performance, consistency, and suitability for various workload requirements.

CAP theoremJavaRedis
0 likes · 24 min read
Implementation Principles of Distributed Locks with Redis and Zookeeper
php Courses
php Courses
Nov 26, 2024 · Databases

Using Redis Bitmap Operations for Precise Statistics with PHP

This article explains Redis bitmap data structures, introduces the main bitmap commands (BITSET, BITGET, BITCOUNT), and provides a complete PHP example that demonstrates how to record user sign‑ins and count them efficiently using Redis bit operations.

BitMapNoSQLPHP
0 likes · 5 min read
Using Redis Bitmap Operations for Precise Statistics with PHP
DeWu Technology
DeWu Technology
Nov 25, 2024 · Databases

Redis Hot Key Detection and Kernel-Based Real-Time Statistics

The article describes a kernel‑level hot‑key detection module for Redis that tracks per‑second access counts via an O(1) LRU queue, flags keys exceeding configurable thresholds, and provides real‑time subscription alerts and queryable logs, overcoming the latency and overhead limitations of existing detection methods.

HotKeyPerformanceRedis
0 likes · 11 min read
Redis Hot Key Detection and Kernel-Based Real-Time Statistics
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 22, 2024 · Backend Development

How to Sync MySQL to Redis in Real-Time with Spring Boot 3 and mysql-binlog-connector-java

This article demonstrates how to achieve real‑time synchronization of MySQL data to Redis using Spring Boot 3, the open‑source mysql‑binlog‑connector‑java library, and optional JMX exposure, providing step‑by‑step setup, code examples for parsing binlog events, listening to changes, and configuring Maven dependencies.

MySQLRedisSpring Boot
0 likes · 10 min read
How to Sync MySQL to Redis in Real-Time with Spring Boot 3 and mysql-binlog-connector-java
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 21, 2024 · Databases

How to Sync Redis with MySQL: Strategies, Code Samples, and Best Practices

This article explains why syncing Redis with MySQL is essential for performance and consistency, and details three implementation methods—database triggers, application-level double writes, and message queues—providing code examples, practical tips, and key considerations for reliable data synchronization.

Data synchronizationDatabase TriggersMessage Queue
0 likes · 8 min read
How to Sync Redis with MySQL: Strategies, Code Samples, and Best Practices