This article aggregates over forty WeChat posts that cover Java interview topics ranging from Redis and hash structures to Spring lifecycle, multithreading, serialization, and database sharding, providing a valuable reference for developers preparing for technical interviews.
This article explains how to achieve interface idempotency in a Spring Boot application by generating a unique token for each request, storing it in Redis, validating the token via a custom annotation and interceptor, and provides complete code examples and testing guidance.
This guide explains the new Redis 6.0 cluster proxy feature, its purpose, and provides step‑by‑step instructions for installing, starting, and connecting to the proxy, including required GCC upgrades and example commands for a smooth setup.
The study traced severe Redis latency spikes in an 8‑core container to the Go runtime mistakenly reading the host’s CPU count, which created hundreds of threads and scheduler contention; limiting GOMAXPROCS to the container’s quota eliminated the jitter, while further gains were suggested by reducing HMGET calls, tuning GC, and upgrading Go.
This guide introduces Redis as a high‑performance key‑value store, covering its core data structures, advantages, persistence mechanisms, publish/subscribe model, transaction handling, and replication strategies with practical command examples.
This article walks through iQIYI's practical approach to database selection, covering key evaluation dimensions, a taxonomy of SQL/NoSQL and OLTP/OLAP workloads, detailed optimizations for MySQL, Redis, Couchbase and the internally built HiKV, as well as multi‑stage operational management and concrete selection recommendations.
This article analyzes the challenges of handling millions of simultaneous train‑ticket purchase requests, presents a multi‑layer load‑balancing architecture, introduces a pre‑deduction inventory strategy using Redis and local memory, and demonstrates a complete Go implementation with performance testing and key architectural insights.
This article examines the key challenges of flash‑sale (秒杀) systems—overselling, massive concurrency, URL exposure, and database coupling—and presents a complete backend design featuring dedicated databases, dynamic URLs, static pages, Redis clustering, Nginx proxy, rate‑limiting, token‑bucket control, asynchronous order queues, and service degradation strategies.
This article explains how to build a self‑healing dynamic proxy pool for 24/7 web crawling using Scrapy and Redis, covering requirements, design, implementation details, deployment steps, and a reusable Scrapy middleware example.
This article dissects the extreme‑load challenges of China’s 12306 train‑ticket service, explains its multi‑layer load‑balancing architecture, and provides a complete Go‑based spike‑system example that uses Nginx weighted round‑robin, Redis atomic stock deduction, and channel‑based locking to safely handle millions of concurrent purchase requests.
During holidays, millions of users scramble for train tickets, overwhelming the 12306 system; this article dissects its high‑concurrency architecture, explains load‑balancing layers, demonstrates Nginx weighted round‑robin configuration, and provides a Go‑based spike simulation with Redis stock management and performance results.
This article examines Suning's bargain‑group platform transformation, detailing its strategic shift to a platform model, high‑availability architecture, vertical and horizontal decomposition, data sharding, cache design, dual‑data‑center deployment, and link optimizations for handling massive concurrent traffic.
Redis creates 16 logical databases by default, a design inherited from its early architecture; this article explains the origin of that number, how to modify it via configuration, the proper way to view these databases as namespaces, and the limitations when using Redis in cluster mode.
The article describes how a hotel quoting team identified recurring Redis‑related outages, designed a comprehensive cache governance plan—including fast recovery, multi‑replica, manual downgrade, and parameter tuning—and executed a structured process that improved system reliability and operational readiness.
This article explains three Redis‑based techniques—using hash tables, bitsets, and the HyperLogLog probabilistic algorithm—to accurately count daily page views, detailing the required commands, implementation steps, advantages, and limitations for high‑traffic sites.
This article explains why caching is essential for Java distributed applications, introduces Redis and Redisson, and demonstrates how to implement distributed caches using Redisson Maps, Spring Cache integration, and the JCache API with practical code examples.
This article explains Flink's sliding window mechanism, shows how the WindowAssigner and WindowOperator work with code examples, analyzes the performance impact of fine‑grained sliding windows, and proposes a practical workaround using tumbling windows combined with external storage such as Redis for efficient PV/UV aggregation.
This article documents a hands‑on experiment that allocates a 50 GB Redis instance on a 64 GB dual‑node machine, explores NUMA behavior, demonstrates how memory affinity can trigger swap, and concludes with practical recommendations for Redis memory sizing and NUMA binding.
This article discusses iQIYI’s approach to database selection, covering evaluation criteria, the variety of databases used—including MySQL, TiDB, Redis, Couchbase, and the in‑house HiKV—along with detailed optimization, high‑availability, auditing, and operational management techniques for each system.
This article presents comprehensive guidelines for Alibaba Cloud Redis, covering readable and concise key naming, value design to avoid big keys, safe command usage, client connection pooling and circuit‑breaker patterns, appropriate eviction policies, and practical code examples for deleting large hashes, lists, sets, and sorted sets.
The article analyzes why a round‑robin load‑balancing approach caused severe response‑time spikes in Ctrip's compute‑intensive international ticket query engine and demonstrates how switching to a proactive pooling model using a Redis‑backed queue eliminated the spikes and reduced average latency by about 20%.
This article explains how to set Redis's maximum memory usage via configuration files or commands, describes the built‑in eviction strategies including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, volatile‑ttl, and shows how to query and change these policies, while also covering LRU fundamentals, a Java LRU cache example, Redis's approximate LRU implementation, its 3.0 optimizations, and the newer LFU eviction algorithm.
This comprehensive guide explores Redis caching fundamentals, data structures, key‑search techniques, distributed lock implementation, asynchronous queues, persistence options (RDB, AOF, hybrid), pipeline usage, replication, Sentinel monitoring, and cluster sharding with consistent hashing to help developers build high‑performance, reliable systems.
This article explains how Redis implements its own string type using Simple Dynamic Strings (SDS), details the internal structure and dynamic expansion mechanism, and highlights the performance benefits such as O(1) length retrieval, buffer‑overflow protection, and reduced memory allocation overhead.
This article explains how to dramatically reduce Redis memory consumption—by up to 90%—through converting long string keys to integers, leveraging zipList‑encoded hashes, and distributing millions of key‑value pairs across many hash buckets while maintaining query performance.
The article explains what Redis cache avalanche, penetration, and breakdown are, illustrates real‑world incidents, and provides pre‑, during‑, and post‑incident solutions such as high‑availability setups, local caches with rate limiting, fallback mechanisms, and placeholder writes to prevent database overload.
This article explains how a distributed delayed‑execution component solves business scenarios that require timed actions, ensuring high availability and data consistency by leveraging Redis sorted sets and RabbitMQ dead‑letter queues, while providing a simple Java API and optional DB‑backed reliability.
An in‑depth guide covering Redis fundamentals, installation steps, daemon configuration, password setup, core commands for strings, lists, hashes, sets and sorted sets, internal encodings, and both RDB and AOF persistence mechanisms, complete with practical code examples and configuration snippets.
This article provides a comprehensive overview of Redis, explaining its core data structures, caching use cases, persistence mechanisms, high‑availability features like Sentinel and replication, clustering for horizontal scaling, and client‑side capabilities such as transactions, Lua scripting, pipelining, and distributed locks.
lmstfy is a stateless, Redis‑backed task‑queue service from Meitu that provides delayed execution, automatic retries, priority handling, expiration, and a RESTful HTTP API, while supporting horizontal scaling via namespace‑based token routing, rich Prometheus metrics, and future disk‑based storage extensions.
This article explains iQIYI's multi‑dimensional approach to database selection, details the practical use and optimization of MySQL, TiDB, Redis, Couchbase, and the internally built HiKV, and offers concrete recommendations for choosing the right database in different scenarios.
This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring MVC interceptor that uses Redis to count requests, register the interceptor in a Spring Boot application, and apply the annotation to controller methods to achieve rate‑limiting functionality.
Redis Sentinel provides an automated high‑availability solution for Redis by monitoring master health, broadcasting SDOWN/ODOWN messages, electing a new master based on priority, offset and runid, and allowing clients to discover the current master via sentinel commands, all explained with configuration examples and diagrams.
This article analyzes a use‑case where each user must keep up to 10,000 historical IDs, compares two Redis‑based implementations—using a List and a String—by presenting code samples and benchmark results, and explains why understanding underlying data structures can dramatically improve performance.
This article details a complete backend solution for a high‑frequency like/unlike feature using Spring Cloud, Redis as a cache, MySQL for persistence, and Quartz to periodically transfer cached data to the database, covering installation, configuration, data modeling, service design, and scheduled tasks.
This article explains Redis cache avalanche, penetration, and breakdown, illustrates real interview scenarios, and provides practical strategies such as random expiration, Bloom filters, and high‑availability setups to help candidates answer these common interview questions confidently.
This article details the design principles, components, client implementation, data sharding, security mechanisms, high‑risk command blocking, configuration optimizations, and automated operational workflows of Qunar's Redis high‑availability cluster, including code modifications, deployment scripts, and platform‑based management for large‑scale production environments.
This article explains how to build a high‑traffic flash‑sale (秒杀) system by leveraging browser and CDN caching, read‑write split Redis for traffic interception, master‑slave Redis for atomic inventory deduction with Lua scripts, and Redis‑based message queues for asynchronous order processing.
This article details the design, requirements, architecture, and operational dashboard of Pepperbus, a unified bus system that standardizes asynchronous task handling for PHP, Java, and Go services at Huajiao, highlighting its storage plug‑in model, Redis‑based protocol, and monitoring capabilities.
This article explains the principles of Bloom filters, their false‑positive behavior, and demonstrates how to implement them using Google Guava in Java and Redis ReBloom via Docker, including code examples and a practical membership‑filtering use case.
This guide outlines practical Redis best practices, covering readable key naming with colons, keeping string values under 10 KB, setting expirations, avoiding O(n) commands, disabling risky commands, leveraging batch operations, and responsibly using the monitor command to maintain performance and stability.
This article provides comprehensive best‑practice guidelines for using Redis, covering data classification, key naming, size and connection limits, cache TTL, recommended client‑hash sharding, and a strict list of prohibited commands and operations to ensure performance, reliability, and maintainability.
The author recounts a grueling ByteDance video interview, detailing technical questions on Django deployment, Nginx configuration, uWSGI internals, Redis fundamentals, heap data structures and quick‑sort coding, while sharing hard‑earned career advice for developers preparing for high‑stakes interviews.
This article explains how to architect a high‑concurrency ticket‑seckill system that can handle one million simultaneous users buying ten thousand tickets, covering load‑balancing strategies, Nginx weighted round‑robin configuration, Go service implementation, Redis‑based inventory management, and performance testing results.
This comprehensive guide details how Codis extends Redis with a proxy‑based architecture to achieve transparent horizontal scaling, smooth data migration, high availability, fault tolerance, and operational best‑practices, while also covering common Redis pitfalls and performance tuning.
This article explains the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing, Nginx weighted round‑robin, local and remote stock deduction, Go implementation, Redis atomic scripts, and performance testing with ApacheBench.
This article explains how Redis manages key expiration using EXPIRE, PEXPIRE, EXPIREAT, and PEXPIREAT commands, details the internal expires dictionary, demonstrates code examples for setting, retrieving, and removing TTL, and discusses the lazy and periodic deletion strategies along with their impact on persistence and replication.
This article explains how to design and implement a high‑frequency like/unlike feature for large social platforms using Spring Cloud, Redis caching, MySQL persistence, and Quartz scheduled jobs, covering Redis setup, data modeling, service interfaces, database schema, and periodic data synchronization.
This article details the design and implementation of MaFengWo's marketing platform for the Double‑11 travel promotion, covering its modular architecture, data layer, flexible development model, reliability mechanisms, and future roadmap to support high‑traffic, secure, and maintainable marketing activities.
This article analyzes the 12306 ticket‑spike scenario, presents a distributed high‑concurrency architecture with layered load balancing, compares order‑creation strategies, demonstrates local and remote stock deduction using Go and Redis, and validates performance with ApacheBench testing.
This article explains how to set Redis's maximum memory usage via configuration files or runtime commands, details the various eviction strategies including noeviction, LRU, random, and LFU, and provides Java code for a simple LRU cache implementation.
This article explains how front‑end teams can leverage the Node.js Bull queue to implement lightweight asynchronous calls, rate‑limiting traffic spikes, and distributed scheduled jobs, detailing the selection rationale, architectural changes, core Redis‑based mechanisms, and practical deployment tips.
This technical guide compiled by Tencent engineers explores common Redis data‑structure use cases, latency and memory considerations, compares distributed deployment options, and provides practical optimization, high‑availability, and troubleshooting techniques for large‑scale Redis (Codis) deployments.
This article explains how to design a high‑concurrency ticket‑sniping service that can handle millions of users by using multi‑layer load balancing, Nginx weighted round‑robin, local stock deduction, Redis for unified inventory, and a Go implementation with performance testing.
This article examines a universal caching solution for business static data in microservice systems, detailing the definition of static data, the need for caching, a six‑component architecture involving Redis, queues, and consistency checks, and the trade‑offs of various design choices.
This article explores the design of a high‑concurrency ticket‑spike system, covering multi‑layer load balancing, weighted Nginx routing, pre‑deduction inventory strategies using Redis, Go implementation details, and performance testing that demonstrates handling millions of requests while preventing oversell and ensuring high availability.
This article demonstrates how to build a one‑second‑refresh real‑time dashboard for e‑commerce order data using Apache Flink, Kafka, and Redis, covering JSON message parsing, processing‑time windows, stateful aggregation for site‑level KPIs, and efficient top‑N product ranking via Redis sorted sets.
This article explains the concept of hash functions and hash tables, illustrates how they map data to array indices, discusses collision resolution methods, and details Redis's internal dictionary implementation, including zipmap optimization, operation complexities, and practical usage differences between hashes and sets.
This guide outlines step‑by‑step methods for migrating a production Redis cluster—including using Redis’s native RDB/AOF backups, JSON‑based redis‑dump, the Alibaba‑maintained RedisShake tool, and Docker‑based cluster setups—ensuring data integrity and minimal downtime during the transition.
This article explains how to build a high‑concurrency train‑ticket flash‑sale system that can handle millions of requests by combining layered load‑balancing, Nginx weighted round‑robin, in‑memory stock deduction, Redis atomic Lua scripts, and a Go HTTP service with channel‑based concurrency control, and it provides performance test results and source code.
This article explains how Redis removes expired keys using periodic and lazy deletion, describes the slave expiration handling, details the asynchronous memory reclamation commands like UNLINK and FLUSHALL ASYNC, and outlines the various maxmemory eviction policies including LRU, LFU, and their implementations.
This article explains the definition of distributed locks, the challenges of mutual exclusion in distributed environments, and compares four implementation approaches—plain Redis, ZooKeeper, and Redisson—detailing their mechanisms, advantages, drawbacks, and practical code examples.
This article analyzes the architecture, load‑balancing strategies, stock‑deduction techniques, and Go/Redis implementation needed to support a million concurrent users purchasing ten thousand train tickets without overselling or underselling.
This article explains how to design a high‑concurrency flash‑sale (秒杀) system by leveraging browser and CDN caching, read‑write split Redis for traffic filtering, Lua scripts for atomic stock deduction, master‑slave Redis for fast inventory updates, and Redis‑based message queues for asynchronous order processing.
This article explains why rate limiting is essential for microservice stability, compares leaky‑bucket and token‑bucket algorithms, shows how to implement local and distributed throttling with Java's AtomicLong, Redis, and a control‑server architecture, and points to an open‑source project for practical use.
This article summarizes Alibaba Cloud Redis’s architecture, including single-node, high‑availability, cluster, read‑write separation, disaster‑recovery options, and hybrid storage, and details its kernel optimizations such as AOF/Binlog enhancements, multi‑threaded I/O, Memcache compatibility, and performance improvements.
This article explains what constitutes data inconsistency in Redis, outlines key and value mismatch scenarios, and introduces the open‑source redis‑full‑check tool with usage instructions for efficiently comparing two Redis instances across various deployment modes.
This article explores the architecture and implementation of a high‑concurrency train‑ticket flash‑sale system, covering load‑balancing strategies, weighted round‑robin Nginx configuration, local and remote stock deduction using Go and Redis, performance testing, and key lessons for building reliable, scalable services.
This article details how Weibo leverages Redis across billions of requests, describing its massive scale, the challenges of trillion‑level reads/writes, the technical choices and customizations made—including LongSet, HA solutions, multi‑level caching, RocksDB integration—and outlines ongoing capacity and future development strategies.
KeyDB is a high‑performance, multithreaded fork of Redis that retains full Redis compatibility while delivering up to twice the query throughput and 60 % lower latency, and the article explains its thread model, connection management, fastlock mechanism, and active‑replica features in detail.
This article explains the three common distributed‑lock implementations, details the requirements for a Redis‑based lock, provides Java code for acquiring and releasing the lock with Lua scripts, discusses the Redlock algorithm, and shows how to use Redisson’s reentrant and RedLock implementations in production.
This article provides a comprehensive guide to Redis persistence mechanisms, covering the internal database structure, detailed operations of RDB snapshotting and AOF command logging, their configurations, advantages, drawbacks, hybrid persistence, and practical strategy recommendations for various deployment scenarios.
This article explains how KeyDB, a Redis fork, redesigns the single‑threaded architecture into a multi‑threaded model with worker threads, per‑thread connection management, a custom fastlock mechanism, and an active‑replica mode that enables writable replicas and conflict‑resolution using timestamps.
This article explains why Redis is chosen for projects—highlighting its performance and concurrency benefits, detailing its data types, expiration and eviction policies, and offering solutions to common issues such as cache consistency, avalanche, penetration, and key‑competition.
This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing architectures, OSPF/LVS/Nginx strategies, pre‑deduction inventory techniques, Go‑based HTTP services, Redis Lua scripts, and performance testing with AB, demonstrating how to achieve stable, scalable ticket‑purchasing under massive traffic.
This tutorial demonstrates how to enable shared HTTP sessions across multiple Spring Boot instances by integrating Apache Shiro with Redis via the CrazyCake plugin, configuring Maven dependencies, Redis and Shiro settings, building service and controller layers, and deploying the applications behind an Nginx load balancer for seamless session persistence.
This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering load‑balancing strategies, weighted Nginx configuration, in‑memory pre‑deduction, Redis Lua scripts, and Go implementation, and demonstrates its performance with real‑world stress testing.
This article explains Redis's expiration policies, detailing how commands like DEL, SET, INCR, LPUSH, PERSIST, RENAME, EXPIRE, and EXPIREAT affect key TTLs, and describes the lazy and periodic deletion mechanisms used by Redis to manage expired keys.
A candid recount of a ByteDance backend interview reveals how superficial preparation, gaps in Nginx, uWSGI, Redis, and data‑structure knowledge, and nervousness can derail even experienced developers, while offering concrete advice on early preparation, resume framing, and tackling tough technical questions.
This article provides a comprehensive introduction to Redis, covering its high‑performance key‑value architecture, supported data structures (string, hash, list, set, sorted set), core commands, persistence mechanisms, replication, sentinel monitoring, sharding, pub/sub messaging and transaction handling, with practical command‑line examples.
This article examines three common Redis performance pitfalls—short-lived connections, frequent INFO commands, and misuse of pipelines—by presenting real‑world experiments, profiling data, and source‑level analysis, then offers concrete code changes and best‑practice recommendations to reduce CPU and memory overhead.
This article explains how to achieve consistent OAuth2 token handling across multiple clients and tenants by customizing the token key generation, overriding DefaultTokenServices logic, and configuring a RedisTokenStore with a custom AuthenticationKeyGenerator in a Spring Boot application.
This article explains how UCloud’s KUN platform leverages Kubernetes Operators to simplify deployment and management of stateful distributed services like Redis, covering Operator fundamentals, design choices, Redis Operator features, scope handling, persistence, monitoring, and the overall benefits for DevOps efficiency.
This article explains the benefits of short URLs, outlines the basic workflow of generating and resolving them, and presents a complete Java implementation that uses Redis for fast storage, MySQL for persistence, and various techniques for high concurrency and distributed deployment.
The article explains how to handle massive simultaneous user requests in a flash‑sale scenario by using rate limiting, caching, asynchronous processing, distributed locks, load balancing, and anti‑cheat mechanisms, illustrated with the Sohu Focus online opening system architecture.
This article compiles essential Redis interview questions covering its advantages over Memcached, performance pitfalls, data structures, persistence options, clustering, scaling strategies, and practical usage patterns such as distributed locks and asynchronous queues, providing concise answers and best‑practice recommendations for each topic.
This article explains the challenges of session sharing in distributed Spring Boot applications, demonstrates how to centralize session data using Redis, and shows how Spring Session simplifies the process by automatically synchronizing session information across multiple Tomcat instances.
This article explains how to implement robust cache‑read logic with Redis, covering common pitfalls such as cache penetration and cache expiration, and demonstrates practical solutions—including placeholder caching and lock‑based cache rebuilding—to keep high‑traffic back‑ends performant and reliable.
This article examines the floating‑point nature of Redis ZSET scores, the precision limits of Java double values, how Redis stores and retrieves these scores, and practical guidelines for avoiding precision loss when using timestamps or large numeric scores in backend development.
This tutorial walks through creating a full‑stack video‑chat app that supports multiple chat rooms, private messaging, user status, and peer‑to‑peer video calls by combining Vue.js for the frontend, Vuex for state management, Socket.io for real‑time communication, a Node/Express backend, Redis for scaling, and Docker for deployment.
This tutorial demonstrates how to integrate the lightweight Apache Shiro security framework into a Spring Boot 2.1.5 project, covering environment setup, Maven dependencies, Redis session storage, custom utilities, Shiro configuration, permission annotations, test controllers, and Postman verification.
This article explains Redis's startup sequence, detailing server initialization, configuration loading, event‑loop creation, supported I/O multiplexing mechanisms, timer and I/O callbacks, and the complete request‑response flow from client command to server reply.
This article shares a practical experience of implementing a Redis‑based distributed lock, explains the lock acquisition and release processes, discusses common pitfalls such as expiration handling and concurrency bugs, and provides Q&A on design choices, high‑availability, and future improvements.
This article explains how MX Player replaced a Redis‑based user‑history list with per‑user Bloom Filters, dramatically reducing memory consumption and improving filtering efficiency for its recommendation system.
This article introduces Redis's fundamental and advanced data structures, explains how each is represented internally, and provides detailed examples of essential commands such as KEYS, EXISTS, DEL, EXPIRE, TTL, and TYPE, highlighting their usage, complexity, and best‑practice considerations.
The article explains how Redis 6 introduced multithreaded network I/O to overcome single‑thread bottlenecks, describes the lock‑free read/write flow, provides benchmark configuration and results showing nearly double GET/SET throughput, and outlines upcoming Redis 6.0 features.
Redis achieves exceptional speed by combining a C‑based implementation, pure in‑memory data storage, a single‑threaded event loop, and non‑blocking epoll I/O multiplexing, while supporting rich data structures and advanced features such as transactions, Lua scripting, and clustering.
To achieve low‑latency, high‑throughput data access in systems like Gaode’s navigation service, the article advises evaluating CPU and I/O bottlenecks, choosing between local (HashMap/ConcurrentHashMap or Caffeine) and distributed caches (Redis preferred), applying appropriate eviction, TTL, and consistency patterns, and mitigating cache penetration, breakdown, and avalanche risks.
This article walks through integrating Apache Shiro into a Spring Boot project to handle authentication, authorization, session management, and caching, including custom realms, Redis-backed sessions, and cache managers, while providing detailed code examples and configuration guidance.
The article details Redis 6’s new multithreaded I/O feature—motivated by network‑I/O bottlenecks, implemented with lock‑free pending‑read queues that offload reads, writes, and protocol parsing to worker threads while keeping command execution single‑threaded—and demonstrates through a simple benchmark that using four I/O threads roughly doubles GET/SET throughput compared with Redis 5.
