BestHub
Sign in
Tagged articles
3240 articles
Page 6 of 33
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.

databasefailoverhigh availability
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.

Apache Commons PoolConnection PoolJedis
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
Selected Java Interview Questions
Selected Java Interview Questions
Feb 18, 2025 · Backend Development

Why Java synchronized Is Insufficient in Distributed Systems and Alternative Lock Solutions

The article explains how Java's synchronized keyword works only within a single JVM, why it fails to provide mutual exclusion across multiple processes in distributed systems, and presents alternative distributed locking mechanisms such as database locks and Redis-based locks with code examples.

concurrencydatabase lockdistributed-lock
0 likes · 8 min read
Why Java synchronized Is Insufficient in Distributed Systems and Alternative Lock Solutions
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.

Cluster ManagementDatabase operationsResource Balancing
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 scriptingSpring Bootredis
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.

ExpirationLazy DeletionMemory Management
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.

BackendLuaSpring Boot
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.

BackendBigKeyCache
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 ManagementKeyDBlocking
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 Monitoringbig key detection
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.

CacheScalabilitydatabase
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 TypesNoSQLcommands
0 likes · 31 min read
Master Redis Data Types and Commands: Strings, Hashes, Lists, Sets, Sorted Sets
MaGe Linux Operations
MaGe Linux Operations
Jan 27, 2025 · Operations

Redis Sentinel Deep Dive: High‑Availability Architecture & Automatic Failover

This article explains Redis Sentinel’s role as the official high‑availability solution, detailing its monitoring, notification, automatic failover mechanisms, discovery processes, connection types, down‑state classifications, failover steps, leader election, master selection rules, and data consistency guarantees.

Operationsfailoverhigh availability
0 likes · 18 min read
Redis Sentinel Deep Dive: High‑Availability Architecture & Automatic Failover
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.

MicroservicesSpring Bootjava
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.

ClusterDatabase OptimizationSlot 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.

Error HandlingLuaSpring 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.

Backend ArchitectureDistributed Systemshigh concurrency
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.

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

cachingdistributed cachelocal 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.

ClusterVirtual Slotsdata sharding
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.

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

Goexternal commandsos/exec
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.

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

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

JavaScriptOnline UsersSorted Set
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.

APIFlaskID generation
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.

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

Luabackend-developmentip blacklist
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.

ConsistencyDelayed Double DeleteLease
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.

BackendLuaNginx
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 ExampleSet OperationsSets
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 commandSCAN
0 likes · 5 min read
Why the Redis KEYS Command Is Dangerous and How to Replace It
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.

ActuatorRoute ManagementSpring Cloud Gateway
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.

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

Database OptimizationLatencyMemory Management
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.

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

BackendDockerNetworking
0 likes · 17 min read
Comprehensive Backend Development Interview Notes: OS Memory, Concurrency, Networking, Databases, Redis, Kafka, and Docker
php Courses
php Courses
Dec 18, 2024 · Backend Development

Backend Development Course: Processes, Sockets, TCP/IP, Nginx, FASTCGI, Byte Order, and Redis

This course provides an in‑depth exploration of process fundamentals, socket programming with TCP/IP, Nginx and FASTCGI communication, host‑to‑network byte order conversion, and Redis basics, targeting backend engineers, system administrators, and network engineers seeking comprehensive backend development skills.

Byte OrderNginxSockets
0 likes · 3 min read
Backend Development Course: Processes, Sockets, TCP/IP, Nginx, FASTCGI, Byte Order, and Redis
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.

Backend ArchitectureMessage QueueRead‑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.

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

Comment SystemData ConsistencyNoSQL
0 likes · 13 min read
Design and Implementation of a Multi-Level Storage Architecture for Bilibili Comment Service
Java Architect Essentials
Java Architect Essentials
Dec 12, 2024 · Backend Development

Build a Secure SMS Verification Service with Spring Boot and Redis

This tutorial walks through creating a simulated SMS verification system using Spring Boot, Redis, and scheduled tasks, covering requirements, dependency setup, controller and service implementation, rate limiting, code expiration, validation logic, and daily reset of usage counters.

BackendCode ExampleSMS Verification
0 likes · 7 min read
Build a Secure SMS Verification Service with Spring Boot and Redis
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 StructuresSign-in
0 likes · 5 min read
How to Use Redis Bitmap for Efficient User Sign‑In Tracking
Java Architect Essentials
Java Architect Essentials
Dec 11, 2024 · Databases

Redis Expiration Listener: Scenario Testing and Performance Analysis

This article examines the pitfalls of using Redis key‑expiration notifications for delayed business actions, presents a Docker‑based benchmark, provides Spring‑Boot code for scheduling and listening to expirations, and analyzes how notification latency grows as the number of keys increases.

Key ExpirationPerformance TestingSpring Boot
0 likes · 11 min read
Redis Expiration Listener: Scenario Testing and Performance Analysis
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.

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

BackendDesign Patternscaching
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.

InnoDBParallel Read_count
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.

BackendShopping Cartclient storage
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.

BackendRabbitMQTime Wheel
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.

Cloud NativeFederated ClustersKubeBlocks
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 theoremZooKeeperdistributed-lock
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.

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

BinlogSpring Bootmysql
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.

Database TriggersMessage QueuePython
0 likes · 8 min read
How to Sync Redis with MySQL: Strategies, Code Samples, and Best Practices
Tencent Cloud Developer
Tencent Cloud Developer
Nov 21, 2024 · Backend Development

Design and Architecture of Feed Stream Systems

The article surveys feed‑stream systems—from their RSS roots to modern social‑media timelines—explaining classifications, core terminology, and a high‑performance architecture that uses Redis ZSET inboxes, write‑ and read‑diffusion, soft‑delete consistency, and last‑id pagination to handle massive real‑time writes, big‑V fan‑out, and efficient publishing and reading.

Message Queuefeed streampagination
0 likes · 21 min read
Design and Architecture of Feed Stream Systems
Architecture Digest
Architecture Digest
Nov 19, 2024 · Backend Development

Implementing Idempotency in Spring Boot Using Redis and Custom Annotations

This article explains the concept of idempotency, identifies which HTTP operations are naturally idempotent, describes why idempotency is needed in scenarios like timeout retries, async callbacks and message queues, and provides a complete Spring Boot implementation using a custom annotation, Redis storage, AOP interception, token generation and example controllers.

BackendIdempotencyredis
0 likes · 8 min read
Implementing Idempotency in Spring Boot Using Redis and Custom Annotations
Bilibili Tech
Bilibili Tech
Nov 19, 2024 · Backend Development

Evolution and Design of Bilibili Customer Service Seat Scheduling System

The article traces Bilibili’s customer‑service seat scheduling system from its initial balanced‑distribution algorithm and Redis‑based priority queues for live chat and ticket handling, through fairness‑focused saturation limits and virtual‑queue mechanisms, to planned dynamic tuning and expertise‑aware routing for future scalability.

System Designcustomer-serviceload balancing
0 likes · 23 min read
Evolution and Design of Bilibili Customer Service Seat Scheduling System
Selected Java Interview Questions
Selected Java Interview Questions
Nov 18, 2024 · Databases

RediSearch Overview: Features, Benchmarks, Installation, and Command‑Line Operations

This article introduces RediSearch—a Redis module for full‑text search—detailing its features, performance comparison with Elasticsearch, index‑building and query benchmarks, installation methods (source and Docker), and comprehensive command‑line examples for creating, querying, updating, and managing indexes.

CLIFull‑Text SearchRediSearch
0 likes · 13 min read
RediSearch Overview: Features, Benchmarks, Installation, and Command‑Line Operations
Top Architect
Top Architect
Nov 12, 2024 · Backend Development

Preventing Duplicate Submissions in Java Backend with Debounce and Distributed Locks

This article explains how to implement request debouncing and distributed locking in a Java backend using Redis and Redisson, covering the definition of debounce, identifying suitable APIs, generating unique keys, and providing complete code examples for both cache‑based and Redisson‑based lock mechanisms.

DebounceSpringBootdistributed-lock
0 likes · 17 min read
Preventing Duplicate Submissions in Java Backend with Debounce and Distributed Locks
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 11, 2024 · Backend Development

Cache Penetration and Four Effective Mitigation Strategies

Cache penetration, a common issue in large-scale websites where malicious or non‑existent key requests bypass caches and overload databases, can cause crashes; this article explains the problem and presents four mitigation techniques—caching empty objects, rate limiting, blacklist mechanisms, and Bloom filters—to protect backend systems.

Backendbloom-filtercache-penetration
0 likes · 4 min read
Cache Penetration and Four Effective Mitigation Strategies
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 11, 2024 · Databases

Is Redis Single‑Threaded? Uncover Its Core Architecture and Multi‑Threading Features

Redis primarily operates with a single thread using I/O multiplexing (select, poll, epoll) to handle massive concurrent connections, while newer versions introduce optional multi‑threaded networking and use child processes for persistence, maintaining its core single‑threaded design for data processing.

Database ArchitectureI/O MultiplexingSingle‑threaded
0 likes · 5 min read
Is Redis Single‑Threaded? Uncover Its Core Architecture and Multi‑Threading Features
Architect
Architect
Nov 10, 2024 · Backend Development

How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson Locks

This article explains why API debouncing is crucial for backend Java services, outlines which endpoints need protection, describes how to identify duplicate requests, and provides step‑by‑step implementations using Redis shared‑cache and Redisson distributed locks with concrete code examples and test results.

BackendDebouncedistributed-lock
0 likes · 14 min read
How to Prevent Duplicate Submissions in Java APIs with Redis and Redisson Locks