The 2018 DB-Engines ranking crowned PostgreSQL as the top DBMS, highlighting its 30‑year evolution, strong community, and expanding features, while MongoDB and Redis secured the runner‑up and third places respectively, and the January 2019 popularity scores showed continued shifts among major database systems.
This article provides a detailed overview of Redis as an open‑source, in‑memory data store, covering its core features, common use cases such as caching and leaderboards, high‑performance characteristics, essential data structures and commands, configuration options, and practical recommendations for production deployment.
This article compares Redis and Memcached across network I/O models, supported data structures, memory management mechanisms, persistence options, consistency guarantees, and clustering approaches, highlighting the strengths and trade‑offs of each in‑memory data store.
Learn how to implement Redis distributed locks in both single‑node and cluster environments, covering lock acquisition and release commands, key pitfalls like master‑slave failover, and the advanced Redlock algorithm with step‑by‑step guidance, Lua scripts, and a PHP lock class example.
This article explains Redis's memory model—including memory statistics, allocation strategies, object types, internal encodings, and practical optimization techniques—so developers can accurately estimate memory usage, reduce fragmentation, and improve overall system efficiency.
This article explains the five Redis data types—String, List, Hash, Set, and Zset—their characteristics, typical use cases, and how to combine them effectively, illustrated with a real‑world hot‑top cache design for a high‑traffic group‑buying system.
The 2018 3306π Shenzhen annual conference, co‑hosted by the 3306π community, Zhishu Hall and vivo, attracted over 150 attendees and featured expert talks on MySQL 8.0, open‑source data‑transfer middleware, TDSQL for finance, RadonDB, InnoDB enhancements, large‑scale Redis clusters, and Youzan database operations, with presentation materials available online.
In high‑concurrency scenarios, using Redis as a buffer can improve performance, but without proper strategies such as delayed double‑delete, cache expiration, or asynchronous binlog‑driven updates, inconsistencies between Redis and MySQL may arise, so this article explains the causes and presents four practical solutions.
This article explains Redis's core data types—String, Hash, List, Set, and Sorted Set—its internal object model, persistence options (RDB and AOF) with their pros and cons, transaction characteristics, master‑slave replication mechanisms, and common caching scenarios and design considerations.
This comprehensive guide explains Redis fundamentals, its rich data structures and common commands, then dives into performance optimization, replication, and clustering, offering practical examples and best‑practice recommendations for building reliable, high‑performance Redis deployments.
During a Redis container migration, slowlog entries suddenly reported 1800 ms latency despite low QPS, leading to a deep investigation that traced the anomaly to a kernel bug affecting the Time Stamp Counter on Skylake‑X CPUs and improper use of gettimeofday for timing.
This guide walks through downloading and installing Redis, adding Java dependencies, creating a Redis DAO with Protostuff serialization, configuring Spring beans, caching seckill data, implementing a MySQL stored procedure for atomic execution, mapping it with MyBatis, updating service and controller layers, and testing the entire workflow.
This guide explains how to monitor critical Redis health indicators—including ping response, client connections, blocked clients, memory usage, fragmentation, cache hit rate, OPS, persistence status, expired keys, and slow logs—to ensure optimal performance and prevent failures.
This article details the design and performance optimization of a live quiz platform, covering overall architecture, user info retrieval, answer submission handling, anti-cheating measures, and Tomcat configuration, highlighting techniques such as request distribution, in‑process caching, asynchronous processing, MQ peak‑shaving, and Redis aggregation.
This guide outlines comprehensive best‑practice recommendations for Alibaba Cloud Redis, covering key naming conventions, value size limits, safe command usage, client connection strategies, memory eviction policies, and useful auxiliary tools to improve reliability and performance.
This article provides a comprehensive guide to Redis high‑availability solutions, detailing Sentinel principles, multiple HA architectures such as DNS‑based, VIP‑based, Keepalived, Redis Cluster, Twemproxy and Codis, and shares practical best‑practice recommendations for deployment and failover.
Redis and Memcached differ significantly in data structure support, memory efficiency, performance, memory management, persistence options, and clustering capabilities, with Redis offering richer data types, server‑side operations, configurable persistence, and native clustering, while Memcached provides simpler key‑value storage, slab allocation, and client‑side distribution.
This article walks through the NewLife.Redis library’s two‑layer architecture, demonstrates basic and advanced usage with C# examples, shows pressure‑testing results, and shares practical tips such as GetAll/SetAll, pipelines, and serialization tricks for high‑throughput big‑data scenarios.
This article introduces Zhuanzhuan's multi‑service storage layer—including MySQL, TiDB, ZZRedis, ZZKV/ZZList, and ZZOS—detailing their applicable scenarios, architectural designs, and the improvements made to address scalability, security, and resource‑usage challenges.
Redis is an open-source, in‑memory key‑value store written in C that supports multiple data structures, offers high‑performance caching, persistence via RDB and AOF, various clustering solutions such as Codis and native Redis Cluster, and is widely used for caching, ranking, session management, queues, and pub/sub.
The article explains how engineers can design robust game special‑event systems by abstracting features into reusable components, applying hook‑based extensibility, and using asynchronous message middleware to handle diverse, time‑critical, high‑risk operations, illustrated with the 37 Platform’s event architecture and configuration‑driven flexibility.
Hotspot keys, caused by massive read‑heavy traffic or server limits, can overload network cards, crash cache shards, and trigger DB bottlenecks, but by employing server‑side caching, Memcache/Redis, local caches, read‑write separation, and proactive hotspot detection, systems can mitigate these issues and scale efficiently.
This article explains the main factors that cause Redis latency—including network bottlenecks, Redis’s single‑threaded design, deployment choices, OS settings, and slow commands—and provides concrete commands and best‑practice solutions to diagnose and reduce the delay.
This guide explains how to create a dynamic IP blacklist using Nginx, Lua, and Redis, covering the background, architecture options, step‑by‑step implementation, and the advantages of a lightweight, shared, and easily updatable solution.
This article recounts a Redis server hijack incident, detailing the detection, forensic investigation, removal of malicious files and cron jobs, and provides practical hardening recommendations to prevent similar attacks on Linux environments.
This article explains how to build a high‑performance red‑packet (hong‑bao) service by configuring a RedisTemplate in Spring, writing an atomic Lua script for stock management, persisting results to a MySQL database via JDBC batch processing, and using @Async to off‑load long‑running tasks, complete with code examples and deployment steps.
An incident where a PHP engineer ran a Redis KEYS * command caused a massive lock, CPU spike, and a cascading database crash, prompting a review of Redis safety rules, command restrictions, and best‑practice alternatives like SCAN to prevent future outages.
The article compares traditional and cloud databases, outlines the performance and management benefits of Tencent Cloud's database SaaS, explains migration tools like DTS, details audit and data‑subscription features, and highlights future trends for cloud‑native data services.
A comprehensive collection of Alipay senior Java interview questions covering JVM garbage collection, concurrency, J.U.C utilities, performance tuning, data structures, MySQL indexing, distributed systems, Redis clustering, middleware, and high‑concurrency solutions for preparation.
This article explains the causes of hot key problems in high‑traffic scenarios, outlines their potential impact on system performance, and presents multiple mitigation strategies—including server‑side caching, Memcache/Redis, local caches, read‑write separation, and proactive hot‑data detection—while comparing their advantages and trade‑offs.
This article explains how to build a high‑concurrency flash‑sale (秒杀) system by separating static page traffic with CDN, using read‑write‑split Redis for early request filtering, applying Lua scripts for atomic inventory deduction, and employing Redis as a simple message queue for asynchronous order persistence.
In this talk, Tencent Cloud senior engineer Zou Peng outlines cloud‑native best practices for Redis 4.0 clusters, detailing a smart‑proxy architecture with gossip‑based management, lazy‑scan big‑key handling, automatic fail‑over, the high‑performance CKV engine, and practical guidance on scaling, sharding, monitoring, and cost‑effective high‑availability deployment.
This article provides a comprehensive introduction to Redis, covering its core concepts, advantages, data structures, persistence mechanisms, eviction policies, clustering, common usage scenarios, and typical interview questions for developers working with this high‑performance in‑memory key‑value store.
This comprehensive guide introduces Redis fundamentals, explores its diverse data structures and essential commands, and delves into advanced topics such as persistence, memory management, pipelining, transactions, clustering, and Java client choices, offering practical tips for deployment, optimization, and architectural decisions.
The article describes how to build a Go‑based backend for a WeChat lottery mini‑program using the Echo framework, Tencent Cloud load balancer, Nginx, Redis and MySQL, detailing the system architecture, API design, database and Redis integration, WeChat login flow, activity state machine, and lessons learned.
Pika 3.0, a C++ open‑source Redis‑compatible storage built on RocksDB, introduces a new blackwidow engine, an improved binlog system, and a more efficient server layer, delivering higher performance, reduced disk usage, extended key length limits, and full Redis ZSET compatibility.
This article explains the performance bottlenecks of MongoDB's geoNear queries in high‑traffic LBS services, analyzes why dense point clusters cause massive scans, and details the introduction of hintScan and hintCorrectNum parameters that reduced scan size and increased QPS by more than tenfold, even outperforming Redis 3.2.
This article explores the fundamentals and practical details of server‑side caching in distributed web systems, covering local vs. distributed caches, Redis instance planning, key‑value modeling, persistence, eviction policies, and CRUD operations with performance‑focused recommendations.
This article details Meitu's engineering of a Redis/Memcached proxy platform, describing why twemproxy was chosen, the limitations of its upstream version, the multi‑process redesign with live configuration reload, added latency metrics, reuse‑port handling, Redis master‑slave support, performance testing, and remaining challenges.
This article explains why Redis is a popular in‑memory key‑value store, defines high availability, enumerates failure scenarios, and walks through four incremental architectures—single instance, master‑slave with one Sentinel, dual Sentinel, and three‑Sentinel with VIP—to achieve a robust, production‑grade Redis deployment.
The article details Meitu's adaptation of Twitter's twemproxy into a multi‑process, hot‑reloading, high‑availability Redis/Memcached proxy, describing its architecture, custom features, performance testing, remaining challenges, and open‑source resources for other engineering teams.
This guide walks through Logstash fundamentals, from creating basic pipelines with input, filter, and output sections to using common plugins such as grok, mutate, date, geoip, multiline, and integrations with NGINX, rsyslog, Redis, and Docker‑based Logspout, providing practical configuration examples and command‑line tips.
In the era of big data, DBAs face higher demands and NoSQL technologies have risen, so this article shares GeTui's KV storage architecture evolution, operational challenges, NoSQL selection criteria, Codis+ enhancements, Aerospike evaluation, monitoring practices, and best‑practice recommendations for scalable database operations.
This article provides a concise overview of three data storage solutions—Hive, MongoDB, and Redis—detailing their core concepts, operational principles, typical use cases, and key characteristics to help developers choose the appropriate technology for various workloads.
The article details Zhihu's internally built Redis platform, covering its architecture, instance types, high‑availability mechanisms, migration from client‑side sharding to Twemproxy, deployment on Kubernetes, scaling strategies, monitoring tools, and future upgrades, providing valuable insights for backend engineers.
The Redis community is urging a rename of the master‑slave replication terminology due to social concerns, but the project's lead highlights significant compatibility costs, outlining short‑term compromises and long‑term redesigns while balancing technical feasibility and community expectations.
This article explains the principles, requirements, and implementation details of distributed lock services, comparing Redis and ZooKeeper approaches, and introduces SharkLock's design built on SharkStore with Raft-based replication, covering lock acquisition, release, reliability, scaling, and failover mechanisms.
This article explains the principles of distributed locks, compares Redis‑based and ZooKeeper‑based implementations, discusses their limitations, and introduces the SharkLock system built on SharkStore with Raft‑based replication, detailing its reliability, dead‑lock prevention, and safety mechanisms.
This article explains the architecture and step‑by‑step workflow of QR code login, covering how the web front‑end, mobile client, and server (including Redis storage and token verification) cooperate to generate a QR code, poll for authentication, and complete a secure user login.
This article provides a comprehensive overview of Redis as a high‑performance, in‑memory key‑value store, explaining its data structures, persistence options, replication, benchmark results, and a wide range of real‑world scenarios where Redis excels over traditional databases.
This article describes the end‑to‑end evolution of a large‑scale order dispatch architecture, covering the shift from simple pool display to algorithmic assignment using data mining, genetic algorithms, timing‑wheel scheduling, and a Redis‑backed implementation to improve delivery efficiency and rider experience.
A comprehensive collection of over 70 interview questions covering Java concurrency, Spring framework, MySQL optimization, JVM internals, Linux command-line tricks, Redis usage, and system monitoring, designed to help backend engineers prepare for technical interviews across major Alibaba subsidiaries.
This article explains how to monitor Redis memory usage with the INFO command, interprets key metrics such as used_memory, used_memory_rss, and mem_fragmentation_ratio, and dives into Redis's internal memory layout, including allocators, redisObject, SDS, and the various object types and their encodings.
This article compiles the most frequently asked Java interview questions—from basic introductions and multithreading concepts to JVM internals, Spring framework details, middleware, database fundamentals, and Redis—providing a comprehensive study guide for job seekers.
This article reviews the common Redis deployment patterns—including single‑instance, master‑slave replication, Sentinel, Cluster and custom solutions—analyzes their strengths and weaknesses, and provides practical configuration tips and recommendations for building reliable, scalable Redis services in production environments.
This article explains Redis’s core concepts, data structures, persistence options, and the reasons behind its exceptional speed—including in‑memory operations, simple data models, single‑threaded design, and efficient I/O multiplexing—while also covering common interview questions about caching and Redis’s threading model.
This article examines five common Redis deployment patterns—single instance, master‑slave replication, Sentinel, Cluster, and custom high‑availability solutions—detailing their architectures, advantages, drawbacks, and practical configuration tips to help engineers choose the most suitable setup for their workloads.
This guide explains how Spring Cloud Gateway replaces Zuul and provides Redis‑based multi‑dimensional rate limiting, covering Maven dependencies, YAML configuration, custom key resolver beans, stress testing, Redis key monitoring, core Java implementation, and the underlying Lua script.
This article explains Redis's core concepts, data structures, persistence options, and why its in‑memory, single‑threaded design combined with multiplexed I/O makes it exceptionally fast, while also covering common interview questions and practical scaling tips.
On August 4 2018, Didi Open Source and the Open Source Database Forum hosted a salon where five industry experts presented the latest advances in open‑source databases—covering Redis multi‑data‑center deployment, MySQL InnoDB Cluster, streaming‑processing architecture, PostGIS GIS solutions, and Redis 5.0 features—followed by a Q&A, a prize draw, and a showcase of Didi’s growing open‑source portfolio.
This article provides a comprehensive overview of caching in large distributed systems, covering CDN, reverse‑proxy, local and distributed caches, popular implementations such as Ehcache, Guava, Memcached and Redis, common pitfalls like consistency and avalanche, and practical solutions with real‑world case studies.
The article presents a detailed case study of the 58 Cloud DB Platform, describing its architecture, automated workflow using Celery and Ansible, and intelligent features such as server selection and alarm merging powered by machine‑learning, highlighting how it streamlines MySQL, Redis, and MongoDB operations for developers and DBAs.
This article explains why distributed caching is essential for high‑concurrency systems, outlines typical use cases, compares Memcached and Redis across features and performance, and discusses common problems such as cache avalanche, penetration, warm‑up, update strategies, and degradation.
Redis Cluster is a distributed system that partitions its keyspace into 16,384 hash slots across up to 16,384 nodes, enabling automatic sharding, slot migration, replication, and high‑availability features such as automatic node discovery, master‑slave election, and online resharding without service interruption.
This article explains the structure of magnet links, the role of DHT in BitTorrent, and provides a step‑by‑step guide to creating a Python‑based magnet link crawler that stores results in Redis and converts them to torrent files using aria2.
Pika 3.0 introduces a new Blackwidow engine, an efficient write‑to‑file binlog, and a streamlined server layer, all designed to boost performance, reduce storage costs, and fully maintain Redis‑compatible functionality for large‑scale deployments.
This article analyzes the principles, advantages, and drawbacks of distributed locking with Redis and Zookeeper, comparing single‑node and cluster scenarios, discussing RedLock, EPHEMERAL znodes, and practical failure cases to help engineers choose the right solution.
This article explains Redis high‑availability concepts, focusing on persistence mechanisms—RDB snapshots and AOF logging—detailing their triggers, execution flows, file formats, configuration options, performance trade‑offs, and practical guidance for choosing and tuning persistence in production environments.
The paper presents a real‑time computation architecture on Alibaba Cloud Blink that scores and ranks non‑timeline feed items within a sliding 72‑hour window, updating rankings every few minutes, using Redis ZSET for fast retrieval, and discusses scaling optimizations such as interval tuning and external join‑and‑rank services.
The article details how Redis’s incremental rehashing can double memory usage and trigger massive key eviction and scan inconsistencies in large‑scale clusters, explains the underlying dictionary structures, demonstrates the cursor bug when tables shrink, and presents a memory‑guard and scan‑cursor patch that resolves both problems.
This article outlines seven frequent misuse patterns in Redis development—such as improper use of collection types, missing expirations, oversized values, inefficient batch operations, unnecessary requests, poor key naming, and unsafe commands—provides real‑world case analyses, and offers practical recommendations to improve Redis health and performance.
This article explores Redis’s advanced features—including data types, master‑slave, sentinel, and cluster architectures, transaction handling, RDB/AOF persistence, pub/sub messaging, and a practical e‑commerce search case study—providing design insights and best‑practice configurations for high‑availability and performance.
This comprehensive guide explains what Redis is, its advantages over memcached, supported data structures, eviction policies, clustering options, persistence mechanisms, memory optimization techniques, and practical use‑cases such as caching, queues, leaderboards, and pub/sub, providing essential knowledge for developers and architects.
This article explains how to design and implement a high‑throughput, second‑level accurate coupon push notification service using Redis Sorted Sets, a distributed task cluster, dynamic queue configuration, and load‑balancing to handle millions of users within a minute.
This article provides a comprehensive overview of Redis, covering why it is used, its performance advantages, data structures, expiration and eviction strategies, cache‑database consistency, handling cache penetration and avalanche, and approaches to concurrent key competition.
This article explains why auto‑increment primary keys are preferred in MySQL, how B+Tree and hash indexes differ, the benefits of composite and partitioned indexes, isolation levels, MVCC, row‑level locking, triggers, stored procedures, optimization tips, MyISAM vs InnoDB, table design guidelines, and also covers Redis architecture, persistence, replication, and eviction policies.
This article explains how to design and deploy a fault‑tolerant Redis architecture using master‑slave replication, multiple Sentinel instances, and a virtual IP so that the service remains available despite process crashes, server outages, or network partitions.
This guide explains how to implement global rate limiting for high‑traffic Spring Boot applications by using Redis caches and MySQL storage, covering request interception, Redis key structures for limits and counters, and dynamic configuration for adding, updating, or deleting limits.
This article provides a comprehensive overview of Redis, covering its performance benefits, single‑threaded speed, data types, expiration policies, memory eviction strategies, consistency challenges with databases, and practical techniques for handling cache penetration, snowball effects, and concurrent key conflicts.
This tutorial explains how to set up a six‑node Redis cluster (three masters and three slaves) on one Linux VM by creating separate directories and configuration files for each instance, installing Ruby tools, starting the instances, and using the redis‑trib.rb script to create and verify the cluster.
This article explains how to build a highly available Redis service using Sentinel, discusses failure scenarios, compares single‑instance, master‑slave, and multi‑Sentinel architectures, and provides practical guidance on deployment, VIP handling, and operational considerations.
This article explains how to design and implement a highly available Redis deployment using master‑slave replication, multiple Redis Sentinel instances, and a virtual IP to provide seamless failover while maintaining simple client connectivity, covering failure scenarios, architecture choices, and practical configuration tips.
This tutorial demonstrates how to quickly build a modern Java web application using Spring Boot, integrate MyBatis as the ORM, configure Redis as a second‑level cache, and write unit tests with H2, providing step‑by‑step code and configuration details for backend developers.
This article shares the design and implementation of a lightweight, robust, and low‑intrusion monitoring management system for microservice traffic, detailing data collection via client filters, Redis‑based structured storage, alerting, rate‑limiting, degradation, and authorization mechanisms, and discusses performance optimizations and future improvements.
This article explains how to design a highly available Redis service using Sentinel, compares four deployment architectures, discusses failure scenarios and quorum requirements, and shows how a virtual IP can provide a single‑point access while ensuring continuous service.
The article outlines Redis 5.0's major new capabilities—including Streams, module APIs, enhanced RDB metadata, cluster management improvements, new sorted‑set commands, active memory defragmentation, HyperLogLog upgrades, better memory reporting, HELP sub‑commands, connection performance, bug fixes, and Jemalloc 5.1—while also detailing important migration notes from version 4.0 and providing a reference link to the Streams introduction.
This article analyzes the recent surge of Redis unauthenticated attacks that install a worm, use pnscan for lateral scanning, modify system settings, and launch cryptocurrency mining, while providing detailed script breakdowns and remediation steps.
This article provides a comprehensive review of Redis, covering why it’s used, its performance advantages, single‑threaded speed, data types and use cases, expiration policies, memory eviction strategies, consistency challenges, and practical solutions for cache penetration, avalanche, and concurrent key competition.
This article outlines Alibaba Cloud Redis development guidelines, covering key naming conventions, value design, command usage, client configuration, lifecycle management, and recommended tools, providing practical recommendations to avoid common pitfalls, improve performance, and ensure reliable operation of Redis in production environments.
This article compares several Redis cluster solutions—including Codis‑style architecture, Alibaba Cloud ApsaraCache, Baidu BDRP 2.0, JD's custom implementation, the official Redis Cluster, AWS ElasticCache, and Baidu Tieba's ksarch‑saas—detailing their components, sharding methods, migration strategies, and deployment scenarios.
This article demonstrates several methods for enabling a web container to communicate with a Redis container in Docker, covering the deprecated link approach, three net-based techniques, and the recommended custom network solution, while highlighting their advantages and limitations.
This article explains how Redis uses a dual‑hashtable structure and a progressive rehash process to handle hash collisions, detailing the rehash conditions, migration steps, and performance implications for in‑memory key‑value storage.
This article explains the principles of distributed locks, discusses why they are needed in distributed applications, and provides a complete Java implementation using Redis’s NX and EX parameters, including lock acquisition, blocking and non‑blocking modes, unlocking with Lua scripts, configuration, usage examples, and testing strategies.
The article investigates massive packet loss in Meituan‑Dianping's Redis service despite 10 Gbps NIC upgrades, traces the issue to kernel receive‑buffer drops and single‑CPU interrupt handling, and presents a step‑by‑step optimization using backlog tuning, CPU and Redis affinity, and NUMA‑aware placement to eliminate drops and improve latency.
This article walks through building a Java‑based flash‑sale (秒杀) service, diagnosing overselling issues, and progressively enhancing it with optimistic locking, distributed rate limiting, Redis caching, and asynchronous Kafka processing to achieve higher throughput and data consistency under heavy concurrency.
This article explains why distributed caching is essential for high‑traffic services, presents three programming approaches (direct code, Spring‑Data‑Redis injection, and annotation‑based), compares three cache‑access patterns, details sharding models, outlines smooth and offline migration steps, and addresses cache penetration, concurrency, avalanche, and transaction support with concrete code examples.
This article explains Redis's memory model—including memory statistics, allocation, object structures, internal encoding, and practical optimization techniques—so developers can accurately estimate memory usage, reduce fragmentation, and choose the most efficient data representations for high‑performance applications.
Meipai’s live‑stream bullet‑comment platform progressed from an initial HTTP‑polling design supporting one million users, through a high‑availability dual‑room architecture, to a scalable long‑connection system with gRPC routing, dynamic degradation, and caching, solving message ordering, Redis bottlenecks, and ensuring seamless user experience.
Ctrip’s real‑time user behavior service, a core foundation for recommendations, ads, and user profiling, was redesigned with a Java‑based stack (Kafka, Storm, Redis, MySQL) to achieve millisecond‑level latency, high availability, and ten‑fold scalability across processing and output flows.
This article explores the concept of short URLs, their practical applications such as social media and QR codes, discusses various generation methods, presents algorithmic designs like incremental ID encoding and caching strategies, and provides a reference implementation for building a reliable URL shortening service.
