BestHub
Sign in
Tagged articles
3240 articles
Page 24 of 33
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 11, 2021 · Databases

Understanding Redis Master‑Slave Replication: Architecture, Setup, and Mechanisms

This article provides a comprehensive guide to Redis high‑availability through master‑slave replication, covering the underlying architecture, step‑by‑step setup, full and partial synchronization processes, buffer management, practical pitfalls, and how the mechanism fits into broader Redis HA solutions.

Full SyncMaster‑SlavePartial Sync
0 likes · 18 min read
Understanding Redis Master‑Slave Replication: Architecture, Setup, and Mechanisms
macrozheng
macrozheng
Mar 11, 2021 · Backend Development

How to Design Scalable Leaderboards with MySQL and Redis: Interview Tips

This article walks through designing a ranking system for interview scenarios, comparing MySQL and Redis implementations, covering sorted‑set operations, handling daily, weekly, and multi‑day leaderboards, scaling to billions of users, and addressing practical considerations beyond pure API usage.

Sorted Setinterviewleaderboard
0 likes · 19 min read
How to Design Scalable Leaderboards with MySQL and Redis: Interview Tips
Top Architect
Top Architect
Mar 10, 2021 · Backend Development

Implementing QR Code Login for Web Applications Using Redis

This article explains how to build a QR code login feature for web applications by coordinating mobile and web servers, generating UUIDs, storing temporary data in Redis, and polling for authentication, providing a practical step‑by‑step guide with diagrams.

QR Code LoginWeChatWeb Authentication
0 likes · 5 min read
Implementing QR Code Login for Web Applications Using Redis
dbaplus Community
dbaplus Community
Mar 8, 2021 · Databases

Why Is My Redis Slowing Down? A Complete Guide to Diagnose and Fix Latency Issues

This comprehensive article walks you through the entire process of identifying why Redis latency spikes, from confirming the slowdown and measuring baseline performance to analyzing slow logs, big keys, expiration patterns, memory limits, fork overhead, AOF settings, CPU binding, swap usage, memory fragmentation, network bandwidth, and finally applying practical optimization techniques.

Latencyredistroubleshooting
0 likes · 40 min read
Why Is My Redis Slowing Down? A Complete Guide to Diagnose and Fix Latency Issues
Selected Java Interview Questions
Selected Java Interview Questions
Mar 8, 2021 · Databases

Understanding Redis Lazy Free and Multi‑Threaded I/O: Architecture and Implementation

This article explains how Redis evolves from a single‑threaded event‑driven cache to using Lazy Free for asynchronous key deletion and multi‑threaded I/O for improved performance, detailing the underlying mechanisms, code implementations, limitations, and comparisons with Tair's threading model.

Database PerformanceLazy FreeMultithreaded I/O
0 likes · 16 min read
Understanding Redis Lazy Free and Multi‑Threaded I/O: Architecture and Implementation
phodal
phodal
Mar 7, 2021 · R&D Management

Can You Gauge a Codebase’s Architecture Health Through Physical Design Metrics?

This article explores how physical design analysis—monitoring file‑system changes, commit frequency, and module size—can reveal the stability, coupling, and learning cost of a large‑scale software project, using Redis as a concrete case study and the open‑source tool Coco for measurement.

Git analysisR&D managementcode metrics
0 likes · 9 min read
Can You Gauge a Codebase’s Architecture Health Through Physical Design Metrics?
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 7, 2021 · Backend Development

Comprehensive Guide to Java Backend Interview Experience and Preparation

This article shares a detailed personal account of multiple Java backend interview rounds, covering technical topics such as JVM, design patterns, distributed locks, Redis, and system design, while also offering practical advice on preparation, self‑presentation, career planning, and interview mindset.

Distributed SystemsJVMbackend interview
0 likes · 14 min read
Comprehensive Guide to Java Backend Interview Experience and Preparation
Java Backend Technology
Java Backend Technology
Mar 4, 2021 · Backend Development

How to Guarantee RabbitMQ Message Delivery: Persistence, Confirm, and Idempotency

This article explores common pitfalls in RabbitMQ message delivery, explains persistence settings and the confirm mechanism, and why they alone can't ensure 100% reliability, then proposes a robust solution combining pre‑persisting messages to Redis, confirm callbacks, scheduled retries, and idempotent consumer design to achieve near‑zero loss.

Confirm MechanismMessage QueueRabbitMQ
0 likes · 11 min read
How to Guarantee RabbitMQ Message Delivery: Persistence, Confirm, and Idempotency
Selected Java Interview Questions
Selected Java Interview Questions
Mar 2, 2021 · Databases

Understanding Redis Data Types, Internal Representation, and Real‑World Use Cases

This article explains that Redis stores all data primarily in memory, describes its seven core data types (String, Hash, List, Set, Sorted Set, Pub/Sub, Transactions), shows how each type is implemented internally, and provides practical examples such as caching, ranking, queues, and real‑time analytics.

BackendData TypesIn-Memory Database
0 likes · 20 min read
Understanding Redis Data Types, Internal Representation, and Real‑World Use Cases
NiuNiu MaTe
NiuNiu MaTe
Mar 2, 2021 · Databases

How to Keep Redis and MySQL Consistent: 4 Proven Strategies for Interviews

This article explains why caching MySQL with Redis is essential, outlines the consistency challenges that arise, and presents four practical solutions—expiration, delete‑then‑repopulate, message‑queue updates, and binlog subscription—along with their pros, cons, and guidance for choosing the right approach in interviews.

Backenddata synchronizationdatabase
0 likes · 8 min read
How to Keep Redis and MySQL Consistent: 4 Proven Strategies for Interviews
php Courses
php Courses
Mar 1, 2021 · Backend Development

Implementing API Rate Limiting with Redis in PHP

This article explains how to implement API request frequency control in PHP using Redis, detailing a function that tracks per‑user request counts within a configurable time window, removes outdated entries, and returns appropriate responses when the limit is exceeded.

APIBackendPHP
0 likes · 3 min read
Implementing API Rate Limiting with Redis in PHP
Architecture Digest
Architecture Digest
Feb 28, 2021 · Databases

Understanding Redis Memory Limits and Eviction Policies

This article explains how to configure Redis's maximum memory, describes the various eviction policies—including noeviction, allkeys‑lru, volatile‑lru, random and ttl strategies—covers how to query and set these policies, and details the LRU and LFU algorithms used by Redis for cache management.

LFULRUeviction
0 likes · 9 min read
Understanding Redis Memory Limits and Eviction Policies
Java Architect Essentials
Java Architect Essentials
Feb 26, 2021 · Backend Development

How to Gracefully Prevent Duplicate Requests on the Server Side

This article explains why duplicate requests—especially write operations—can cause serious issues, outlines common causes such as replay attacks and client retries, and provides a comprehensive server‑side solution using unique request IDs, Redis, and MD5‑based parameter deduplication with Java code examples.

IdempotencyMD5duplicate request
0 likes · 9 min read
How to Gracefully Prevent Duplicate Requests on the Server Side
Java Backend Technology
Java Backend Technology
Feb 26, 2021 · Databases

Redis Memory Limits & Eviction: LRU, LFU, and Config Guide

Learn how to set Redis's maximum memory usage, understand its various eviction policies—including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, volatile‑ttl, and the newer LFU strategies—plus see Java code examples and insights into approximate LRU implementation.

Eviction PoliciesLFULRU
0 likes · 13 min read
Redis Memory Limits & Eviction: LRU, LFU, and Config Guide
Architect
Architect
Feb 25, 2021 · Databases

Redis Expiration, Eviction Policies, and LRU/LFU Algorithms

This article explains how Redis handles key expiration, the commands for setting TTL, the three expiration strategies, the eight eviction policies, and the internal LRU and LFU algorithms, including their implementation details, sampling techniques, and configuration parameters for memory management.

Eviction PoliciesLFULRU
0 likes · 13 min read
Redis Expiration, Eviction Policies, and LRU/LFU Algorithms
Top Architect
Top Architect
Feb 24, 2021 · Databases

Understanding Redis Memory Limits and Eviction Policies (LRU, LFU)

This article explains how to set Redis's maximum memory usage, configure eviction policies such as noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, and LFU, demonstrates command‑line and configuration‑file methods, and provides a Java implementation of an LRU cache.

LFULRUMemory Management
0 likes · 12 min read
Understanding Redis Memory Limits and Eviction Policies (LRU, LFU)
Open Source Linux
Open Source Linux
Feb 22, 2021 · Operations

How to Deploy and Use JumpServer for Secure Remote Access on Linux

This guide walks you through installing JumpServer—a secure bastion host—on CentOS, covering architecture overview, MariaDB and Redis setup, Docker configuration, container deployment, key generation, UI access, and essential administration tasks such as user, asset, and permission management.

Bastion HostDockerJumpServer
0 likes · 15 min read
How to Deploy and Use JumpServer for Secure Remote Access on Linux
Top Architect
Top Architect
Feb 15, 2021 · Backend Development

Implementing API Idempotency in SpringBoot Using Redis Token Mechanism

This tutorial explains the concept of idempotency, why it is needed for reliable APIs, the impact on system design, and provides four implementation strategies—including a detailed SpringBoot example that uses Redis tokens, Lua scripts, and unit tests—to ensure that repeated requests produce the same result without side effects.

IdempotencyRESTful APISpringBoot
0 likes · 18 min read
Implementing API Idempotency in SpringBoot Using Redis Token Mechanism
21CTO
21CTO
Feb 14, 2021 · Backend Development

How to Gracefully Prevent Duplicate Requests with Redis and Java

This article explains why duplicate requests—especially those that modify data—can be dangerous, outlines common causes, and provides a comprehensive server‑side solution using unique request IDs, parameter hashing, and a Java utility class with Redis to reliably deduplicate incoming calls.

IdempotencyRequest Handlingdeduplication
0 likes · 8 min read
How to Gracefully Prevent Duplicate Requests with Redis and Java
Architect
Architect
Feb 14, 2021 · Backend Development

Message Idempotency and Exactly‑Once Processing in RocketMQ

This article explains why message middleware like RocketMQ guarantees at‑least‑once delivery, the resulting duplicate‑delivery problem, and presents both transaction‑based and non‑transactional idempotency solutions—including select‑for‑update, optimistic locking, and a Redis‑backed deduplication table—to achieve exactly‑once semantics in distributed systems.

Distributed SystemsExactly-OnceRocketMQ
0 likes · 16 min read
Message Idempotency and Exactly‑Once Processing in RocketMQ
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 7, 2021 · Big Data

Building a Flink SQL Platform on Zeppelin: Installation, Configuration, and Advanced Use Cases

This guide walks through setting up Apache Zeppelin as a low‑cost, SQL‑centric development platform for Flink, covering environment preparation, installation, interpreter configuration, execution modes, verification, common pitfalls, dimension‑table joins, custom UDFs, Redis integration, and dual‑stream join techniques.

FlinkStreamingUDF
0 likes · 24 min read
Building a Flink SQL Platform on Zeppelin: Installation, Configuration, and Advanced Use Cases
Practical DevOps Architecture
Practical DevOps Architecture
Feb 4, 2021 · Databases

Redis Interview Questions: Caching Pitfalls, Persistence Options, Memory Optimization, and Eviction Policies

This article presents common Redis interview questions covering cache penetration, breakdown, and avalanche, explains RDB and AOF persistence mechanisms with configuration commands, and details memory‑size tuning, LRU/LFU/RANDOM eviction policies, plus a practical flushAll scenario.

Eviction PoliciesMemory OptimizationPersistence
0 likes · 9 min read
Redis Interview Questions: Caching Pitfalls, Persistence Options, Memory Optimization, and Eviction Policies
Efficient Ops
Efficient Ops
Feb 3, 2021 · Databases

Master Redis: Core Data Types, Commands, and Advanced Features Explained

This article introduces Redis as an open‑source, in‑memory data‑structure store, explains its role as a NoSQL database, details its five fundamental data types, common commands, expiration handling, pipelines, and transactions, and shows how it fits into modern scaling architectures.

Data StructuresNoSQLTransactions
0 likes · 14 min read
Master Redis: Core Data Types, Commands, and Advanced Features Explained
Laravel Tech Community
Laravel Tech Community
Jan 31, 2021 · Backend Development

Wind Framework 1.0.3 Release Notes

Version 1.0.3 of the pure PHP coroutine Wind Framework introduces a new Chan class for intra-process coroutine messaging, enhances the message queue with Redis and Beanstalk drivers supporting massive consumer counts and timeout settings, and fixes several Beanstalk client command errors.

BeanstalkFrameworkMessage Queue
0 likes · 2 min read
Wind Framework 1.0.3 Release Notes
Efficient Ops
Efficient Ops
Jan 27, 2021 · Databases

Mastering Redis Persistence: RDB vs AOF Explained

This article explains Redis persistence mechanisms, detailing how RDB snapshots and AOF append‑only logs work, how to enable and configure them, their advantages and drawbacks, and guidance on choosing the right method for reliable data storage.

AOFNoSQLPersistence
0 likes · 12 min read
Mastering Redis Persistence: RDB vs AOF Explained
Laravel Tech Community
Laravel Tech Community
Jan 26, 2021 · Backend Development

Engineering the Bifrost WebSocket Gateway at Postman: Architecture, Scaling, and Lessons Learned

The article recounts how Postman's Service Foundation team identified the limitations of the monolithic Sync service, designed and built the Bifrost WebSocket gateway using Fastify, AWS ElastiCache for Redis, and a private API, and scaled it through horizontal expansion and custom load‑factor metrics while sharing practical engineering insights.

AWSBackend ArchitectureFastify
0 likes · 12 min read
Engineering the Bifrost WebSocket Gateway at Postman: Architecture, Scaling, and Lessons Learned
High Availability Architecture
High Availability Architecture
Jan 22, 2021 · Databases

Comprehensive Guide to Diagnosing and Optimizing Redis Performance Issues

Redis can experience latency spikes due to factors such as complex commands, big keys, expiration patterns, memory limits, fork overhead, AOF persistence, CPU binding, swap usage, memory fragmentation, and network saturation, and this article provides a systematic troubleshooting methodology and practical optimization solutions for each scenario.

Latencydatabasememory
0 likes · 38 min read
Comprehensive Guide to Diagnosing and Optimizing Redis Performance Issues
Practical DevOps Architecture
Practical DevOps Architecture
Jan 22, 2021 · Databases

Redis Common Data Types and Commands Overview

This article introduces Redis's primary data structures—String, Hash, List, and Set—explaining their purpose, key commands, and practical usage examples, including batch operations, numeric adjustments, field management, list manipulation, and set operations, to help developers effectively work with the in‑memory database.

Data Typescommandsdatabase
0 likes · 6 min read
Redis Common Data Types and Commands Overview
Code Ape Tech Column
Code Ape Tech Column
Jan 21, 2021 · Interview Experience

Master Distributed System Interview Questions: CAP, Redis, Zookeeper, Kafka and More

This article compiles essential interview‑style questions and detailed answers on distributed system fundamentals—including CAP and BASE theories, consistency models, distributed transactions, Redis features and persistence, Zookeeper coordination, Kafka architecture, and common design patterns for high‑concurrency scenarios.

Distributed SystemsKafkaMessage Queue
0 likes · 38 min read
Master Distributed System Interview Questions: CAP, Redis, Zookeeper, Kafka and More
Code Ape Tech Column
Code Ape Tech Column
Jan 19, 2021 · Backend Development

Avoid Common Pitfalls in Distributed Caching with Redis and Memcached

This article analyzes the characteristics of Redis and Memcached, explains typical design mistakes such as inconsistent hashing, cache avalanche, penetration, and hot‑key issues, and provides practical solutions like consistent hashing, binlog‑driven cache invalidation, key versioning, and distributed locking to improve cache reliability and performance.

Cache ConsistencyHot KeyMemcached
0 likes · 22 min read
Avoid Common Pitfalls in Distributed Caching with Redis and Memcached
Java Captain
Java Captain
Jan 16, 2021 · Backend Development

Cinema Ticketing System Project Overview

This article presents a cinema ticketing system built with the SSM framework, MySQL, Redis, Alipay sandbox, LayUI, and Baidu ECharts, highlighting its architecture, features such as payment and seat selection, and providing source code link and screenshots.

AlipayEChartsMyBatis
0 likes · 1 min read
Cinema Ticketing System Project Overview
Practical DevOps Architecture
Practical DevOps Architecture
Jan 16, 2021 · Databases

Redis Configuration Guide: redis.conf Settings, Slowlog, Advanced Options, Replication, and Persistence

This comprehensive guide details the essential redis.conf parameters—including daemonization, networking, memory limits, logging, slowlog, advanced data structure encodings, replication options, and persistence settings—providing clear explanations and recommended values for optimal Redis deployment.

PersistenceReplicationdatabase
0 likes · 8 min read
Redis Configuration Guide: redis.conf Settings, Slowlog, Advanced Options, Replication, and Persistence
Top Architect
Top Architect
Jan 15, 2021 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, massive concurrent requests, URL exposure, and database bottlenecks—and presents a comprehensive backend architecture that combines separate databases, dynamic URLs, static pages, Redis clustering, Nginx load balancing, SQL optimization, rate‑limiting, asynchronous order processing, and service degradation techniques.

Nginxbackend designflash sale
0 likes · 13 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
dbaplus Community
dbaplus Community
Jan 12, 2021 · Operations

Choosing Between Prometheus and Zabbix: A Practical Guide to High‑Availability Monitoring

This technical guide walks through the fundamentals of Prometheus, compares it with Zabbix, demonstrates high‑availability setups, remote storage with InfluxDB, multi‑instance Redis monitoring, and Grafana integration, providing concrete configuration examples and best‑practice recommendations for reliable ops monitoring.

GrafanaHAInfluxDB
0 likes · 17 min read
Choosing Between Prometheus and Zabbix: A Practical Guide to High‑Availability Monitoring
Big Data Technology & Architecture
Big Data Technology & Architecture
Jan 12, 2021 · Backend Development

go-mysql-transfer: A Go-Based Real-Time MySQL Binlog Incremental Sync Tool

The article introduces go-mysql-transfer, a Go-implemented MySQL binlog incremental synchronization solution that avoids extra components, supports multiple downstreams like Redis, offers Lua scripting, Prometheus monitoring, high‑availability clustering, retry mechanisms, full data initialization, and provides installation, deployment, and performance testing details.

BinlogGoPrometheus
0 likes · 12 min read
go-mysql-transfer: A Go-Based Real-Time MySQL Binlog Incremental Sync Tool
Code Ape Tech Column
Code Ape Tech Column
Jan 12, 2021 · Backend Development

How to Build a High‑Performance Search API with SQL and Redis Caching

This article walks through three progressively better implementations for a complex e‑commerce search API—starting with a monolithic SQL query, then splitting the query and adding indexes, and finally using Redis sets and sorted sets to cache filter results, handle pagination, and achieve production‑grade performance.

Backendpaginationperformance
0 likes · 8 min read
How to Build a High‑Performance Search API with SQL and Redis Caching
21CTO
21CTO
Jan 9, 2021 · Backend Development

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

This article explores the key challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, and database strain—and presents a comprehensive backend architecture with database design, dynamic URLs, caching, rate limiting, async ordering, and service degradation techniques.

Backend ArchitectureDatabase designasynchronous processing
0 likes · 13 min read
How to Build a Robust Flash‑Sale System that Handles Millions of Requests
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 9, 2021 · Backend Development

Preventing Redis Cache Avalanche: Interview Dialogue and Practical Solutions

This article presents an interview scenario where a candidate is asked about Redis cache avalanche, explains the phenomenon, and offers four practical mitigation strategies—including cache pre‑warming, mutex locking, staggered expiration, and high‑availability designs—to keep backend databases from being overwhelmed.

Backendcache-avalanchecaching strategies
0 likes · 4 min read
Preventing Redis Cache Avalanche: Interview Dialogue and Practical Solutions
Java Interview Crash Guide
Java Interview Crash Guide
Jan 8, 2021 · Backend Development

Mastering API Idempotency: Strategies, Code Samples, and Best Practices

Idempotency ensures that repeated API calls produce the same effect as a single call, preventing duplicate submissions, token misuse, and inconsistent data; this guide explains the concept, its importance, HTTP definitions, impact on systems, and presents four practical implementation methods—unique keys, optimistic locking, token‑based guards, and sequence numbers—with full SpringBoot and Redis code examples.

APIIdempotencySpringBoot
0 likes · 20 min read
Mastering API Idempotency: Strategies, Code Samples, and Best Practices
vivo Internet Technology
vivo Internet Technology
Jan 6, 2021 · Big Data

How HyperLogLog Estimates Cardinality in Massive Data Sets

This article explains the cardinality‑counting problem behind DAU/MAU and unique visitor metrics, compares naïve solutions like Set, Bitmap and Bloom filter, introduces big‑data algorithms such as Linear Counting, LogLog and HyperLogLog, and shows how Redis implements HyperLogLog with dense and sparse storage optimizations.

Big DataCardinalityHyperLogLog
0 likes · 17 min read
How HyperLogLog Estimates Cardinality in Massive Data Sets
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Jan 4, 2021 · Backend Development

How I Optimized a Node.js Enterprise WeChat Sync Service: Lessons & Solutions

This article walks through the design, pitfalls, and deep optimizations of a Node.js + TypeScript backend that periodically syncs enterprise WeChat organization data to a MySQL store and provides a phone‑number lookup API, offering practical solutions for rate limits, process management, database conflicts, and error recovery.

Node.jsSchedulingWeChat API
0 likes · 10 min read
How I Optimized a Node.js Enterprise WeChat Sync Service: Lessons & Solutions
New Oriental Technology
New Oriental Technology
Jan 4, 2021 · Backend Development

Overview of New Oriental Architecture Department Unified Management Platform

The document provides a detailed technical overview of New Oriental's unified management platform, describing its five core modules—Redis platform, microservice platform, gateway platform, app management platform, and permission management platform—including monitoring, cluster management, service registration, and access control features.

Backend Managementpermission managementplatform architecture
0 likes · 5 min read
Overview of New Oriental Architecture Department Unified Management Platform
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 3, 2021 · Backend Development

Understanding Cache Penetration, Cache Breakdown, and Cache Avalanche in Redis

The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis, illustrates each problem with real‑world analogies, and presents practical mitigation techniques such as null caching, Bloom filters, mutex locks, asynchronous refresh, varied TTLs, and clustering to ensure robust backend performance.

BackendCachecache-avalanche
0 likes · 6 min read
Understanding Cache Penetration, Cache Breakdown, and Cache Avalanche in Redis
Top Architect
Top Architect
Dec 30, 2020 · Databases

Redis Latency Analysis: Common Causes and How to Diagnose Them

This article explains why Redis latency can suddenly increase, covering high‑complexity commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network overload, and provides concrete diagnostic commands and mitigation strategies.

Latencymemoryperformance
0 likes · 18 min read
Redis Latency Analysis: Common Causes and How to Diagnose Them
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 30, 2020 · Databases

Redis Memory Eviction Policies, Expiration Strategies, Cache Issues, Deployment Modes, and Persistence Mechanisms

This article explains Redis’s memory eviction policies, expiration strategies, common cache problems such as penetration, breakdown, and avalanche, outlines deployment modes, compares RDB and AOF persistence, and lists typical business scenarios for using Redis as a high‑performance key‑value store.

Cache StrategiesPersistencedatabase
0 likes · 9 min read
Redis Memory Eviction Policies, Expiration Strategies, Cache Issues, Deployment Modes, and Persistence Mechanisms
Architecture Digest
Architecture Digest
Dec 30, 2020 · Databases

Redis Latency Analysis and Mitigation Strategies

This article examines common causes of increased latency in Redis—including high‑complexity commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—and provides practical monitoring and configuration techniques to diagnose and reduce delays.

Latencymonitoringoptimization
0 likes · 17 min read
Redis Latency Analysis and Mitigation Strategies
MaGe Linux Operations
MaGe Linux Operations
Dec 27, 2020 · Operations

Step‑by‑Step Guide to Deploy JumpServer with Docker, MariaDB & Redis

This tutorial walks you through installing JumpServer—a bastion host for centralized server management—by setting up MariaDB and Redis on separate nodes, configuring Docker, pulling the JumpServer image, generating required secret keys, and finally configuring users, groups, assets and session replay through the web UI.

Bastion HostDevOpsDocker
0 likes · 15 min read
Step‑by‑Step Guide to Deploy JumpServer with Docker, MariaDB & Redis
Architect
Architect
Dec 27, 2020 · Backend Development

Understanding Cache Penetration, Breakdown, and Avalanche with Redis and Bloom Filters

This article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis, presents common mitigation techniques such as request validation, empty‑value caching, Bloom filters, mutex locks, and high‑availability strategies, and includes Java code examples for practical implementation.

BackendCachebloom-filter
0 likes · 8 min read
Understanding Cache Penetration, Breakdown, and Avalanche with Redis and Bloom Filters
Programmer DD
Programmer DD
Dec 26, 2020 · Databases

Understanding Redis Persistence: RDB vs AOF Explained

This article explains Redis persistence mechanisms, detailing how the in‑memory database can lose data on shutdown and how the two main durability options—RDB snapshots and AOF append‑only logs—work, their configuration commands, their advantages, disadvantages, and guidance on choosing the right approach for production use.

AOFNoSQLPersistence
0 likes · 13 min read
Understanding Redis Persistence: RDB vs AOF Explained
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Dec 25, 2020 · Backend Development

Implementing Message Queues with Redis: Lists, Zsets, Pub/Sub, and Streams

This article explains how Redis can be used to build lightweight, high‑performance message queues by leveraging lists for simple queues, sorted sets for delayed delivery, Pub/Sub for multicast, and the Stream data structure for durable, scalable messaging, while also covering practical PHP implementations, acknowledgment, retry, graceful restart, and rate‑limiting techniques.

Message QueuePHPPubSub
0 likes · 19 min read
Implementing Message Queues with Redis: Lists, Zsets, Pub/Sub, and Streams
360 Quality & Efficiency
360 Quality & Efficiency
Dec 25, 2020 · Backend Development

Evolution of Redis Distributed Locks and Redisson Implementation Analysis

This article explains how distributed lock requirements arise when scaling from monolithic to multi‑server architectures, reviews the evolution of Redis‑based locking mechanisms from simple SETNX to Lua scripts and Redisson's advanced features, and provides detailed source‑code analysis of Redisson's lock, unlock, and lock acquisition implementations.

Lockconcurrencyredis
0 likes · 12 min read
Evolution of Redis Distributed Locks and Redisson Implementation Analysis
Ctrip Technology
Ctrip Technology
Dec 24, 2020 · Databases

CTrip Redis Governance Evolution: Horizontal Scaling and Shrinking Solution

This article describes how CTrip tackled rapid Redis cluster growth by moving from vertical scaling to a containerized horizontal splitting approach, then introduced a binlog‑server based horizontal expansion and shrinkage method that reduces operation time, eliminates data migration, supports both scaling up and down, and improves resource utilization.

ContainerizationDatabase operationsredis
0 likes · 13 min read
CTrip Redis Governance Evolution: Horizontal Scaling and Shrinking Solution
Fulu Network R&D Team
Fulu Network R&D Team
Dec 23, 2020 · Information Security

Practical Implementation of IdentityServer4 in the Fuluteng Project

This article provides a hands‑on guide to using IdentityServer4 in the Fuluteng project, covering signing credentials, client and resource stores, persisted grant storage with Redis, various OAuth2 grant types including client credentials, authorization code, password, and custom extensions such as SMS and third‑party logins, and demonstrates role‑based authorization and JWT configuration.

ASP.NET CoreAuthenticationCustom Grant
0 likes · 26 min read
Practical Implementation of IdentityServer4 in the Fuluteng Project
Top Architect
Top Architect
Dec 22, 2020 · Backend Development

Design and Implementation of a High‑Concurrency Short URL Service

This article explains the benefits of short URLs, outlines their basic workflow, and details a backend design that uses an incremental issuer, base conversion, persistent storage, caching, batch ID allocation, and distributed issuers to achieve efficient, high‑concurrency short‑URL generation.

high concurrencyjavaredis
0 likes · 10 min read
Design and Implementation of a High‑Concurrency Short URL Service
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 22, 2020 · Backend Development

How Short URLs Work: From Generation to High‑Performance Service Design

This article explains why short URLs are used in SMS and other platforms, outlines their benefits, describes the basic workflow of mapping long URLs to short ones, and dives into backend design choices such as incremental ID generation, storage strategies, caching, batch allocation, and distributed generation using Redis and Java.

Backendhigh concurrencyjava
0 likes · 11 min read
How Short URLs Work: From Generation to High‑Performance Service Design
Code Ape Tech Column
Code Ape Tech Column
Dec 22, 2020 · Databases

Comparison and Review of Popular Redis Visualization Tools

This article evaluates and compares a range of Redis visualization tools—including desktop clients, web applications, and IDE plugins—by examining their features, usability, platform support, pricing, and command‑line integration to help developers choose the most suitable solution for their workflow.

Desktop ClientIDE pluginTool comparison
0 likes · 9 min read
Comparison and Review of Popular Redis Visualization Tools
Code Ape Tech Column
Code Ape Tech Column
Dec 21, 2020 · Backend Development

13 Proven Redis Performance Tweaks Every Engineer Should Apply

This article presents thirteen practical Redis performance‑optimization rules—covering command complexity, key expiration, data structures, persistence, hardware choices, clustering, memory fragmentation, and client‑side techniques—to help developers identify bottlenecks and boost throughput and latency in production environments.

BackendMemory ManagementScalability
0 likes · 12 min read
13 Proven Redis Performance Tweaks Every Engineer Should Apply
Java Backend Technology
Java Backend Technology
Dec 19, 2020 · Databases

Deep Dive into Redis: Data Structures, Persistence, and High Availability

This comprehensive guide explores Redis internals, covering its core data types and their low‑level implementations, persistence mechanisms like RDB and AOF, performance tricks, common pitfalls such as cache avalanche and split‑brain, distributed locking strategies, expiration and eviction policies, high‑availability architectures, and rate‑limiting techniques.

Persistencehigh availabilityrate limiting
0 likes · 35 min read
Deep Dive into Redis: Data Structures, Persistence, and High Availability
Top Architect
Top Architect
Dec 18, 2020 · Fundamentals

Understanding Bloom Filters: Principles, Applications, and Java Implementations with Guava and Redis

This article explains Bloom filters, their core principles, typical use cases like cache penetration and large‑scale membership testing, and demonstrates practical Java implementations using Guava and Redis, including code examples, performance analysis, and discussion of their advantages and limitations.

Guavabloom-filtercache-penetration
0 likes · 12 min read
Understanding Bloom Filters: Principles, Applications, and Java Implementations with Guava and Redis
Architect's Tech Stack
Architect's Tech Stack
Dec 18, 2020 · Databases

How to Use Redis to Count Website Visits: Hash, Bitset, and Probabilistic Algorithms

This article explains three Redis-based approaches—using Hashes, Bitsets, and the HyperLogLog probabilistic algorithm—to count daily website visits, detailing command usage, advantages, disadvantages, and implementation considerations for high‑traffic sites, including handling logged‑in and anonymous users, memory consumption, and accuracy trade‑offs.

Data StructuresProbabilistic AlgorithmsWeb Analytics
0 likes · 6 min read
How to Use Redis to Count Website Visits: Hash, Bitset, and Probabilistic Algorithms
Laravel Tech Community
Laravel Tech Community
Dec 15, 2020 · Backend Development

lock4j-spring-boot-starter 2.1.0 Release Overview

lock4j-spring-boot-starter is a Spring Boot distributed lock library that provides simple yet powerful locking capabilities with support for Redisson, RedisTemplate, and Zookeeper, and the 2.1.0 release adds global configuration, executor enhancements, default priority ordering, and both declarative and programmatic usage options.

BackendSpring BootZooKeeper
0 likes · 2 min read
lock4j-spring-boot-starter 2.1.0 Release Overview
FunTester
FunTester
Dec 15, 2020 · Backend Development

Run All Scrapy Spiders Together and Fix Video Download Errors

This guide shows how to create a custom Scrapy command to launch every spider at once, separate each spider's settings for better modularity, and resolve video download problems by adjusting request headers and handling file saving correctly.

BackendCustom CommandPython
0 likes · 5 min read
Run All Scrapy Spiders Together and Fix Video Download Errors
Programmer DD
Programmer DD
Dec 14, 2020 · Databases

Master Redis: Explore All 8 Data Types and Essential Commands

This guide walks through Redis’s eight core data structures—String, List, Set, Hash, Sorted Set, Geospatial, HyperLogLog, and Bitmap—detailing their commands, practical usage scenarios, and example interactions to help developers ace interview questions and optimize NoSQL solutions.

Data TypesNoSQLcommands
0 likes · 24 min read
Master Redis: Explore All 8 Data Types and Essential Commands
Code Ape Tech Column
Code Ape Tech Column
Dec 12, 2020 · Backend Development

Building a Scalable Short‑URL Service with Redis and Java

Short URLs are popular in SMS and social media because they save characters, look tidy, enable analytics, and hide parameters; this article explains their benefits, the basic redirect workflow, and provides a detailed backend design—including storage choices, high‑concurrency strategies, distributed ID generation, and a Java‑Redis implementation.

Backenddistributed systemhigh concurrency
0 likes · 11 min read
Building a Scalable Short‑URL Service with Redis and Java
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 11, 2020 · Backend Development

Common Cache Read/Write Strategies for Production Environments

This article reviews five widely used cache read/write strategies—including simple write‑DB‑then‑cache, Cache‑Aside, Write/Read‑Through, Write‑Back, and LRU eviction—explaining their workflows, advantages, disadvantages, and suitability for different production scenarios.

Cachebackend-developmentcaching strategies
0 likes · 7 min read
Common Cache Read/Write Strategies for Production Environments
Top Architect
Top Architect
Dec 11, 2020 · Backend Development

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

This article explains how to build a high‑concurrency ticket‑spike system by analyzing 12306's extreme load, introducing multi‑layer load balancing (OSPF, LVS, Nginx), comparing stock‑deduction strategies, and presenting a Go prototype that uses in‑memory stock, Redis centralized inventory, and weighted Nginx routing to achieve scalable, fault‑tolerant performance.

GoNginxhigh-concurrency
0 likes · 19 min read
Designing a High-Concurrency Ticket‑Spiking System with Load Balancing, Redis, and Go
IT Architects Alliance
IT Architects Alliance
Dec 10, 2020 · Backend Development

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

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering distributed load‑balancing, Nginx weighted round‑robin configuration, Go‑based local and remote stock deduction with Redis, performance testing, and strategies to avoid overselling and underselling.

Godistributed systemhigh concurrency
0 likes · 19 min read
Designing a High‑Concurrency Ticket Spike System: Load Balancing, Stock Deduction, and Go Implementation
Selected Java Interview Questions
Selected Java Interview Questions
Dec 8, 2020 · Backend Development

High‑Concurrency Performance Tuning of a Java SSM E‑commerce Project: Diagnosis, Optimization, and Results

This article details a complete end‑to‑end high‑concurrency tuning process for a Java SSM monolithic e‑commerce system, covering problem identification, root‑cause analysis, a series of JVM, Tomcat, Redis and JDBC optimizations, horizontal scaling, code refactoring, and the resulting stability improvements.

JVMSSMTomcat
0 likes · 9 min read
High‑Concurrency Performance Tuning of a Java SSM E‑commerce Project: Diagnosis, Optimization, and Results
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 7, 2020 · Backend Development

How to Build a Million-User Ticket Spike System with Go, Nginx, and Redis

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system inspired by China’s 12306 platform, covering load‑balancing strategies, Nginx weighted round‑robin, local and remote inventory deduction, Go concurrency patterns, Redis atomic operations, and performance testing results.

Goredisticketing system
0 likes · 21 min read
How to Build a Million-User Ticket Spike System with Go, Nginx, and Redis