Tagged articles
high-concurrency
48 articles · Page 1 of 1
This article breaks down the end‑to‑end design of a high‑traffic red‑envelope service, covering its three‑stage lifecycle, a fair double‑mean allocation algorithm, the need to separate grabbing from settlement, and how Redis, Lua scripts, and message queues handle massive concurrent requests.
BackendDistributed LockMessage Queue
0 likes · 7 min read

To survive a million concurrent flash‑sale clicks, the article breaks down a production‑grade, five‑layer architecture—CDN, load balancer, API gateway, Redis/Lua stock control, message‑queue order processing, and a state‑machine fallback—that filters traffic early, uses atomic operations, and decouples writes to keep database load to just a few QPS.
LuaMessage QueueMySQL
0 likes · 7 min read

Facing explosive growth, the game‑service platform 悠悠有品 rebuilt its architecture on Alibaba Cloud, using RocketMQ for core transaction messaging and Kafka for data synchronization, achieving elastic scaling, high availability, cost reduction, and reliable high‑concurrency processing across its trading and analytics pipelines.
Game PlatformKafkaRocketMQ
0 likes · 8 min read

The article explains a MySQL kernel‑level merged seckill optimization that replaces traditional queue‑based flash‑sale handling, achieving up to 5‑fold throughput gains (up to 1.5 W/s) without requiring SQL changes, detailing background, performance results, bottleneck analysis, design of cache visibility, leader‑follower coordination, row‑lock refinements, binlog parallelism, and crash‑recovery considerations.
MySQLdatabase-optimizationhigh-concurrency
0 likes · 12 min read

This article presents a step‑by‑step architecture for a high‑traffic flash‑sale system that filters 99.9% of requests before the database, using layered front‑end, gateway, cache, message‑queue, and stateless scaling techniques to achieve over 100,000 TPS with strong consistency and availability.
backend-architecturecircuit breakingflash sale
0 likes · 10 min read

The article debunks the myth that Spring Boot cannot scale, showing that with WebFlux, Netty, Reactive Redis, GraalVM Native Image and horizontal scaling a Spring Boot service can reliably achieve 500,000 queries per second, backed by concrete benchmark data and a full demo implementation.
Horizontal ScalingNative ImageNetty
0 likes · 10 min read

The article explains what a GC spike (Garbage Collection Spike) is, analyzes its typical causes such as large short‑lived objects, memory leaks, and heap configuration, presents a real‑world high‑concurrency case study, and details step‑by‑step JVM tuning and architectural strategies that reduced latency spikes and raised service availability from 95% to over 99.99%.
G1GCGCJVM tuning
0 likes · 32 min read

Discover proven strategies to optimize Nginx under extreme traffic, covering benchmark testing, kernel tuning, configuration tweaks, caching, load balancing, SSL hardening, monitoring, and real-world case studies that demonstrate how to achieve stable high‑QPS performance while minimizing latency and resource usage.
high-concurrencyload-balancingmonitoring
0 likes · 22 min read

This article outlines a comprehensive engineering roadmap for constructing a high‑performance, highly available open platform capable of handling billions of daily API calls, covering three‑layer architecture, multi‑level caching, asynchronous messaging, database sharding, distributed transactions, and progressive scaling strategies.
Open Platformdistributed architecturehigh-concurrency
0 likes · 18 min read

The article explains how Spring Cloud Gateway leverages a fully non‑blocking, reactive architecture built on Project Reactor and Netty to handle millions of concurrent requests, and discusses essential protection mechanisms such as rate limiting, circuit breaking, and degradation for high‑traffic scenarios.
Spring Cloud Gatewaycircuit breakinghigh-concurrency
0 likes · 6 min read

This article explains the core functions of a short‑URL system, compares permanent (301) and temporary (302) redirects, details four generation methods—including hash, auto‑increment, random strings, and pre‑generation—and outlines a high‑concurrency architecture with sharding, caching, and Snowflake IDs.
Snowflakehigh-concurrencyshorturl
0 likes · 9 min read

The article examines why relying solely on threads cannot achieve single‑machine million‑level concurrency, analyzing thread resource consumption, context‑switch overhead, and contrasting it with user‑space coroutine scheduling that offers predictable, low‑cost switches, making coroutines better suited for IO‑intensive high‑concurrency scenarios.
CoroutinesSchedulinghigh-concurrency
0 likes · 6 min read

The article analyzes why relying solely on operating‑system threads cannot easily achieve single‑machine million‑level concurrency, examining thread stack memory misconceptions, kernel‑level context‑switch costs, and how user‑space coroutine scheduling overcomes these limits.
ConcurrencyCoroutinesIO Multiplexing
0 likes · 6 min read

The article details a large‑scale Chinese New Year interactive activity’s front‑end architecture, describing a layered system for business logic, data abstraction, and animation engines, unified data handling, dynamic animation rendering with downgrade paths, high‑concurrency QPS reduction, resilience measures, and extensive performance and workflow optimizations.
Data ManagementResilienceanimation
0 likes · 15 min read

This article explains Redis's atomic counter commands (INCR, INCRBY, DECR, DECRBY), highlights their pitfalls such as missing TTL and concurrency issues, and presents practical design solutions—including SET NX+EX initialization, double‑TTL compensation, retry queues, fallback strategies, and performance optimizations like Lua scripting and pipelining.)
CounterTTLdecr
0 likes · 10 min read

Tencent Meeting optimized its “My Recordings” list by replacing offset pagination with cursor‑based seeks, implementing a two‑layer cache separating ID lists from record details, choosing MongoDB for multi‑source aggregation, and adding reliable Kafka‑driven sync, cutting latency from 308 ms to 70 ms while supporting over 700 QPS.
BackendCachingMongoDB
0 likes · 36 min read

This article analyzes the challenges faced by Ctrip's ticket‑booking transaction system during high‑traffic flash‑sale events and presents a series of architectural optimizations—including Redis caching, database load mitigation, supplier‑system safeguards, and fine‑grained traffic‑control strategies—to achieve stable, consistent, and fast performance under extreme concurrency.
Backenddatabase optimizationflash sale
0 likes · 15 min read

This article recounts the end‑to‑end design, testing, and iterative optimization of a volunteer registration platform that required tens of thousands of QPS, covering requirement analysis, middleware benchmarking, data partitioning, compression, connection‑limit handling, and final deployment lessons.
RocketMQhigh-concurrencyperformance-testing
0 likes · 16 min read

This article explains how to build a high‑performance Go server capable of processing up to one million requests per minute using efficient goroutine‑pool patterns, detailing the design of two worker structures, their dispatch, start, stop mechanisms, and practical optimizations.
ConcurrencyGogo-optimization
0 likes · 16 min read

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, detailing load‑balancing strategies, in‑memory stock deduction, Redis atomic operations, and Go code examples that enable millions of users to purchase tickets simultaneously without overselling or underselling.
distributed-systemshigh-concurrencyload-balancing
0 likes · 19 min read

This article outlines the end‑to‑end design of a high‑availability flash‑sale system, covering traffic spikes, overload protection, inventory consistency, multi‑level caching, token‑bucket rate limiting, distributed queue processing, service monitoring, and stress‑testing strategies to ensure reliable million‑level transaction handling.
Cachingdistributed-systemshigh-concurrency
0 likes · 15 min read


21CTOMar 24, 2023 · Backend Development
This article dissects the architecture of a 12306‑style ticket‑spiking service, explaining load‑balancing strategies, weighted Nginx routing, local and remote stock deduction using Go and Redis, and demonstrates performance testing that achieves thousands of requests per second while preventing oversell and undersell.
BackendGohigh-concurrency
0 likes · 20 min read

This article details vivo's low‑code platform experience, covering a front‑end/back‑end separated low‑code solution, a self‑built high‑performance rendering engine, efficient visual configuration methods, billion‑scale content delivery, and how low‑code coexists with traditional development to boost productivity and scalability.
Backendhigh-concurrencylow-code
0 likes · 16 min read

This article describes the design, hardware and software setup, implementation, testing phases, and performance analysis of a Go‑based backend system that simulates a Spring Festival red‑envelope service capable of handling up to 10 billion requests with peak loads of 60 k QPS per server.
BackendSimulationdistributed-systems
0 likes · 19 min read

This article explores the architecture and implementation of a high‑concurrency train ticket flash‑sale system, detailing load‑balancing strategies, Nginx weighted round‑robin, Redis‑based inventory management, and Go code examples that demonstrate local and remote stock deduction, performance testing, and fault‑tolerant design.
BackendGohigh-concurrency
0 likes · 20 min read

The article details Meituan's five‑year journey in instant logistics, describing the evolution from early vertical services to micro‑service and cloud‑native architectures, the technical challenges of massive order‑rider matching, high availability, AI‑driven optimization, and the operational practices adopted to ensure scalability and reliability.
AIdistributed-systemshigh-concurrency
0 likes · 10 min read

This article explains the fundamental cache‑aside pattern, why lazy cache deletion is preferred over immediate updates, analyzes simple and complex cache‑database inconsistency scenarios, and proposes a high‑concurrency queue‑based solution with practical considerations for backend systems.
Cache AsideConsistencydistributed-systems
0 likes · 11 min read

This article explains how the author designed and implemented a Go‑based backend that can simulate up to 100 million concurrent users and process billions of red‑packet requests, detailing the hardware setup, performance goals, load‑balancing techniques, monitoring, and the results of multi‑stage stress tests.
Simulationgolanghigh-concurrency
0 likes · 17 min read

This article provides a comprehensive analysis of Kafka Broker's network and request‑handling architecture, tracing its evolution from a simple sequential model through multithreaded and event‑driven designs to a Reactor‑based NIO implementation, and offers concrete tuning recommendations for high‑concurrency deployments.
Reactor Patternhigh-concurrencyjava-nio
0 likes · 22 min read

This article explores the design and implementation of a high‑concurrency train ticket spike system, detailing load‑balancing strategies with Nginx, distributed inventory management using Redis, Go‑based services, and performance testing, while addressing challenges such as overselling, fault tolerance, and efficient resource utilization.
GoNGINXhigh-concurrency
0 likes · 19 min read

In 2021, ByteDance leveraged its cloud‑native stack—including traffic governance, service mesh, and rapid deployment pipelines—to deliver 703 billion red‑envelope interactions during the Spring Festival Gala, overcoming a 27‑day preparation window, high‑concurrency demands, and extensive emergency rehearsals to ensure seamless user experience.
cloud-nativehigh-concurrencyservice-mesh
0 likes · 16 min read

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

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, local stock deduction in Go, remote stock control with Redis Lua scripts, and performance testing results.
GoNGINXdistributed
0 likes · 19 min read

This article explains the cache‑aside pattern, why deleting cache entries is often preferable to updating them, outlines basic and complex cache‑database inconsistency scenarios, and presents a queue‑driven approach with practical considerations for maintaining data consistency in high‑concurrency backend systems.
CacheCache AsideConsistency
0 likes · 10 min read

This article describes the design, implementation, and performance testing of a simulated WeChat red‑packet service capable of handling up to 100 billion requests, detailing target load calculations, hardware and software choices, concurrency strategies in Go, monitoring tools, and experimental results across multiple QPS levels.
backend-architecturedistributed-systemsgolang
0 likes · 18 min read

This article explains the key challenges of flash‑sale systems—overselling, massive concurrency, URL exposure, and database pressure—and presents a complete backend design with isolated databases, Redis clustering, dynamic URLs, rate‑limiting, asynchronous order processing, and service degradation strategies.
flash salehigh-concurrencyrate-limiting
0 likes · 15 min read


21CTOMar 6, 2020 · Backend Development
This article details a backend engineering practice that simulates 100 billion shake‑red‑packet requests by building a single‑machine prototype supporting one million connections, achieving peak QPS of 60 k, and demonstrates the methodology, hardware setup, code design, monitoring, and performance analysis.
Backenddistributed-systemsgolang
0 likes · 18 min read

This article explores how recent Python performance improvements and the ultra‑fast Japronto microframework enable handling over a million HTTP requests per second, detailing benchmark results, HTTP pipelining optimizations, C extensions, memory management tricks, and the underlying technologies that make such throughput possible.
HTTPMicroframeworkasync
0 likes · 9 min read


21CTONov 26, 2019 · Backend Development
This article explores the design of a high‑concurrency ticket‑spike system that can handle millions of simultaneous requests by combining multi‑layer load balancing, Nginx weighted round‑robin, Redis for atomic stock control, and Go‑based services, complete with code samples and performance testing.
distributed systemhigh-concurrencyload-balancing
0 likes · 20 min read

This article explains how to build a high‑concurrency ticket‑seckill system using Go, Nginx weighted load balancing, and Redis, covering architecture design, local and remote stock deduction, Lua scripting for atomic operations, and performance testing with ApacheBench to achieve thousands of requests per second without overselling.
GoNGINXdistributed-systems
0 likes · 19 min read

The article explains how distributed cache consistency problems arise with read‑write operations, introduces the Cache‑Aside pattern and lazy‑deletion strategy, analyzes simple and complex inconsistency scenarios, and proposes a queue‑driven, serial processing solution with practical considerations for high‑concurrency backend systems.
BackendCache AsideQueue
0 likes · 11 min read

This tutorial walks through creating a Java SSM‑based high‑concurrency seckill application, covering project workflow, environment setup, Maven dependencies, database schema, entity classes, MyBatis mapper interfaces and XML configurations, as well as testing and common MySQL version pitfalls.
Webhigh-concurrency
0 likes · 23 min read

This article explains how WeChat redesigned its red‑packet system for the 2016 Chinese New Year, detailing the dual‑data‑center architecture, order and user data separation, caching layers, traffic routing, high‑concurrency controls, database sharding, and graceful degradation to handle tens of billions of requests per minute.
BackendWeChatdistributed-systems
0 likes · 13 min read

This article describes Ctrip's design of a distributed, globally unique user ID generator for MySQL migration, covering requirements, evaluation of common approaches such as auto‑increment, UUID, Snowflake and Redis, and detailing the final Flicker‑based solution with segment caching using AtomicLong to achieve high concurrency and reliability.
BackendUnique IDdistributed-systems
0 likes · 9 min read

Alibaba's Double 11 festival broke sales records with 120.7 billion RMB, and the article details the backend engineering challenges and solutions—such as database sharding, SQL optimization, multi‑level caching, and modular architecture—that enabled the platform to handle millions of orders per second while preserving data consistency and performance.
BackendCachingdatabase
0 likes · 20 min read

This article explores how to build a high‑traffic insurance O2O platform for tens of millions of users by emphasizing simple micro‑service architecture, detailed functional requirements, performance targets, distributed storage, caching, service registration, and a practical technology stack for reliable, extensible backend development.
architecturedistributed-systemshigh-concurrency
0 likes · 19 min read

This article revisits the technical design and evolution of the 2015 Chinese New Year Gala "shake" activity, detailing how the backend architecture was progressively refined—from a simple prototype to a production‑grade system capable of handling tens of millions of concurrent requests—through resource pre‑download, access‑layer integration, load‑balancing, and robust fail‑over mechanisms.
distributed-systemshigh-concurrencyload-testing
0 likes · 21 min read

This article explains how to design and implement an efficient Golang‑based server‑client monitoring solution called OWL, covering data packet structures, network protocols, client and server architecture, concurrency handling with goroutines, and practical code examples for high‑throughput operations.
Server-Clientgolanghigh-concurrency
0 likes · 12 min read
