BestHub
Sign in
Tagged articles
756 articles
Page 6 of 8
Java Architect Essentials
Java Architect Essentials
Sep 2, 2020 · Backend Development

Designing a High-Concurrency Flash Sale (Seckill) System: Architecture, Challenges, and Solutions

This article presents a comprehensive design of a flash‑sale system, covering business scenario analysis, high‑concurrency problems such as overselling and malicious requests, and detailed front‑end, Nginx, risk‑control, back‑end, database, and distributed‑transaction solutions to ensure reliability and performance.

System Designdistributed-transactionflash sale
0 likes · 16 min read
Designing a High-Concurrency Flash Sale (Seckill) System: Architecture, Challenges, and Solutions
Java Architect Essentials
Java Architect Essentials
Aug 31, 2020 · Operations

End-to-End Online High-Concurrency Tuning for a Monolithic SSM E‑Commerce System

This article presents a practical, step‑by‑step walkthrough of identifying, diagnosing, and resolving high‑concurrency performance problems in a Java‑based SSM e‑commerce application, covering monitoring, root‑cause analysis, JVM/Tomcat/Redis/JDBC tuning, code improvements, and the resulting system stability.

JVM OptimizationSSMTomcat
0 likes · 8 min read
End-to-End Online High-Concurrency Tuning for a Monolithic SSM E‑Commerce System
Top Architect
Top Architect
Aug 28, 2020 · Backend Development

Comprehensive Performance Tuning of a High‑Concurrency SSM E‑Commerce Application

This article details a step‑by‑step performance tuning process for an SSM‑based e‑commerce system experiencing severe CPU, memory, Redis, and JDBC issues during flash‑sale spikes, covering root‑cause analysis, JVM and Tomcat optimizations, connection‑pool adjustments, code refactoring, and the resulting stability improvements.

JVMSSMTomcat
0 likes · 7 min read
Comprehensive Performance Tuning of a High‑Concurrency SSM E‑Commerce Application
Architecture Digest
Architecture Digest
Aug 23, 2020 · Backend Development

End-to-End Performance Optimization of a High-Concurrency SSM E‑Commerce System

This article presents a comprehensive, practical case study of diagnosing and resolving high‑concurrency performance issues in an SSM‑based e‑commerce system, covering architecture overview, problem identification, root‑cause analysis, JVM/Tomcat/Redis/MySQL tuning, load‑balancing, and post‑optimization monitoring results.

JVM OptimizationSSMbackend-development
0 likes · 8 min read
End-to-End Performance Optimization of a High-Concurrency SSM E‑Commerce System
Java Architect Essentials
Java Architect Essentials
Aug 20, 2020 · Backend Development

High-Concurrency Architecture Design and Practices for E‑commerce Systems

This article presents a comprehensive guide to designing high‑concurrency architectures for e‑commerce applications, covering server topology, load balancing, database clustering, caching strategies, concurrency testing tools, message‑queue based asynchronous processing, first‑level cache, static data handling, layering, distribution, service‑oriented design, redundancy, automation, and practical implementation examples.

asynchronous processingcachinghigh concurrency
0 likes · 19 min read
High-Concurrency Architecture Design and Practices for E‑commerce Systems
21CTO
21CTO
Aug 12, 2020 · Backend Development

How to Build a High‑Performance Distributed Unique ID Generator with MySQL and Redis

This article explains the challenges of generating globally unique IDs in sharded databases, compares common solutions such as auto‑increment, UUID, Snowflake, and Redis, and presents a practical MySQL‑based design that uses table‑level auto‑increment combined with in‑memory segment allocation to achieve high concurrency, reliability, and performance.

System Designdistributed-idhigh concurrency
0 likes · 9 min read
How to Build a High‑Performance Distributed Unique ID Generator with MySQL and Redis
Beike Product & Technology
Beike Product & Technology
Jul 31, 2020 · Backend Development

Design and High‑Concurrency Optimization of QR Code Generation Service for a Real Estate Platform

This article analyzes the challenges of generating massive QR codes for a real‑estate mini‑program, including URL length, concurrency limits, and path management, and presents a backend‑focused solution that uses short‑URL services, request‑id binding, pre‑generation, caching, and Kafka to achieve scalable, low‑latency QR code delivery.

BackendQR codehigh concurrency
0 likes · 10 min read
Design and High‑Concurrency Optimization of QR Code Generation Service for a Real Estate Platform
Java Backend Technology
Java Backend Technology
Jul 31, 2020 · Backend Development

Why Redis Distributed Locks Can Fail: Real-World Over‑Sale Case & Fixes

This article analyzes a real over‑selling incident caused by unsafe Redis distributed locks, explains the root causes such as lock expiration and non‑atomic stock checks, and presents safer lock implementations, atomic stock updates, and architectural improvements to prevent future failures.

distributed-lockhigh concurrencyjava
0 likes · 11 min read
Why Redis Distributed Locks Can Fail: Real-World Over‑Sale Case & Fixes
JavaEdge
JavaEdge
Jul 24, 2020 · Backend Development

Designing High‑Concurrency Systems: Key Strategies Interviewers Expect

This guide explains practical techniques—service splitting, caching, message queues, database sharding, read/write separation, and Elasticsearch—to design high‑concurrency back‑end systems that impress interviewers and handle real‑world traffic spikes.

Message QueueMicroservicesSystem Design
0 likes · 6 min read
Designing High‑Concurrency Systems: Key Strategies Interviewers Expect
Tencent Cloud Developer
Tencent Cloud Developer
Jul 17, 2020 · Frontend Development

Creating a Stunning Countdown Timer and Real‑Time Interactive Mini‑Program for Massive Online Events

This article details the technical design and implementation of a CSS‑based countdown timer, component‑driven multi‑platform development, and a high‑concurrency real‑time interaction system using WeChat Cloud Development's watch API for Tencent Games' 2020 online conference.

CSSReal-TimeWeChat Mini Program
0 likes · 15 min read
Creating a Stunning Countdown Timer and Real‑Time Interactive Mini‑Program for Massive Online Events
Java Backend Technology
Java Backend Technology
Jul 9, 2020 · Backend Development

How to Solve Distributed Cache Consistency Issues with Lazy Updates

This article explains the Cache Aside pattern, why deleting stale cache entries is often better than updating them, and presents a queue‑based lazy‑update solution that handles simple and complex consistency problems in high‑concurrency environments while outlining practical performance considerations.

BackendCacheConsistency
0 likes · 11 min read
How to Solve Distributed Cache Consistency Issues with Lazy Updates
dbaplus Community
dbaplus Community
Jul 2, 2020 · Backend Development

Why High Concurrency Is Really About Squeezing CPU Performance

The article explains that high concurrency in distributed systems is measured by QPS, but its essence lies in effectively utilizing CPU resources, discusses control‑variable analysis of the HTTP request flow, compares PHP‑Swoole and Java‑Netty implementations, and shows how coroutine‑based designs can dramatically boost throughput when I/O blocking is present.

Backend PerformanceNettySwoole
0 likes · 15 min read
Why High Concurrency Is Really About Squeezing CPU Performance
Selected Java Interview Questions
Selected Java Interview Questions
Jun 28, 2020 · Backend Development

Rate Limiting Strategies and Guava RateLimiter for High Concurrency Traffic

This article explains the concept of high traffic, compares common mitigation techniques such as caching, degradation and rate limiting, and then details four classic rate‑limiting algorithms—counter, sliding window, leaky bucket and token bucket—followed by a practical Guava RateLimiter example and a brief note on distributed scenarios.

Distributed SystemsGuavahigh concurrency
0 likes · 7 min read
Rate Limiting Strategies and Guava RateLimiter for High Concurrency Traffic
dbaplus Community
dbaplus Community
Jun 23, 2020 · Backend Development

How to Build a High‑Performance Seckill System for Massive Traffic

This article explains the core concepts, architecture, and practical techniques—including load‑balancing, caching, async processing, and Redis sharding—required to design and implement a high‑concurrency seckill system that can handle millions of requests in a short time window.

Backend ArchitectureSeckillasync-processing
0 likes · 19 min read
How to Build a High‑Performance Seckill System for Massive Traffic
Qunar Tech Salon
Qunar Tech Salon
Jun 23, 2020 · Operations

A Simple Gray Release Solution for High‑Concurrency Flight Ticket Systems

This article presents a lightweight gray release approach for complex flight ticket services, comparing traditional hardware and soft‑routing isolation methods, describing the authors' traffic‑based gray identification, business‑focused monitoring, implementation details, and automated safeguards to enable safe incremental deployments.

BackendDeploymentOperations
0 likes · 8 min read
A Simple Gray Release Solution for High‑Concurrency Flight Ticket Systems
21CTO
21CTO
Jun 13, 2020 · Backend Development

How RocketMQ Transformed Alibaba’s Logistics System for Double‑11 Peaks

This article examines the logistical challenges faced by Alibaba's Cainiao platform during Double‑11, explains why traditional databases and Redis fall short, and shows how adopting RocketMQ for asynchronous decoupling dramatically reduced costs and stabilized high‑volume order processing.

Backend ArchitectureDistributed MessagingRocketMQ
0 likes · 6 min read
How RocketMQ Transformed Alibaba’s Logistics System for Double‑11 Peaks
iQIYI Technical Product Team
iQIYI Technical Product Team
Jun 5, 2020 · Backend Development

Design and Implementation of iQiyi's libfiber Network Coroutine Library

Using iQiyi’s open‑source libfiber as a case study, the article explains how network coroutines combine sequential programming simplicity with non‑blocking I/O scalability, detailing libfiber’s single‑threaded scheduler, cross‑platform event engine, coroutine‑aware synchronization, API hooking, and its deployment in high‑performance CDN caching and DNS services.

Network programmingcoroutinehigh concurrency
0 likes · 26 min read
Design and Implementation of iQiyi's libfiber Network Coroutine Library
Laravel Tech Community
Laravel Tech Community
May 17, 2020 · Databases

Can MySQL Handle 100,000 Concurrent Connections? A Real‑World Test

This article details a comprehensive experiment that evaluates MySQL's ability to sustain up to 100,000 simultaneous connections using Percona Server's thread‑pool plugin, sysbench clients, adjusted OS/network limits, and multiple IP addresses, presenting hardware specs, configuration steps, observed errors, performance metrics, and practical recommendations.

Sysbenchdatabase scalinghigh concurrency
0 likes · 8 min read
Can MySQL Handle 100,000 Concurrent Connections? A Real‑World Test
Java Backend Technology
Java Backend Technology
May 14, 2020 · Backend Development

How to Build a High‑Performance Flash Sale System: Architecture & Code

This article explores the key challenges of designing a flash‑sale (秒杀) backend—such as overselling, high concurrency, request throttling, and database bottlenecks—and presents a complete solution that includes database schema, dynamic URLs, static page rendering, Redis clustering, Nginx load balancing, SQL optimization, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.

Backend Architectureflash salehigh concurrency
0 likes · 14 min read
How to Build a High‑Performance Flash Sale System: Architecture & Code
Top Architect
Top Architect
May 12, 2020 · Backend Development

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

This article explores the challenges of building a flash‑sale (秒杀) backend—such as overselling, massive concurrent requests, URL protection, and database bottlenecks—and presents a comprehensive architecture that leverages Redis clustering, token‑bucket rate limiting, static page rendering, asynchronous order processing, and service degradation techniques.

flash salehigh concurrencyrate limiting
0 likes · 12 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
58 Tech
58 Tech
May 8, 2020 · Backend Development

Optimizing High‑Concurrency List Service for 58 Used‑Car Platform: Data Query, Transformation, and Thread‑Pool Tuning

This article analyzes the performance bottlenecks of the 58 used‑car list service under high concurrency, breaks down data‑query and data‑transfer stages, and presents three optimization solutions—including query redesign, concurrent data conversion, and thread‑pool parameter tuning—that together reduce latency by over 80 ms and improve resource utilization.

concurrencyhigh concurrencyjava
0 likes · 9 min read
Optimizing High‑Concurrency List Service for 58 Used‑Car Platform: Data Query, Transformation, and Thread‑Pool Tuning
Programmer DD
Programmer DD
May 5, 2020 · Backend Development

How to Build a High‑Concurrency Live Quiz System: Architecture & Tech Stack

This article explains the product features, technical challenges, technology choices, and detailed architecture design for a live‑streaming quiz application that must support up to one million concurrent users, high QPS, low latency, and secure financial transactions.

Backend ArchitectureProtobufWebSocket
0 likes · 18 min read
How to Build a High‑Concurrency Live Quiz System: Architecture & Tech Stack
Tencent Cloud Developer
Tencent Cloud Developer
Apr 24, 2020 · Backend Development

Mask Reservation Mini‑Program: From Perfect Experience to Lossy Service – Architecture and Design

During the COVID‑19 pandemic, Tencent and Guangzhou built the “Suikang” mask‑reservation mini‑program in two days, handling 1.7 billion visits by shifting from real‑time inventory checks to a four‑layer “lossy” architecture—CDN caching, batch releases, Redis, Kafka queues, and asynchronous processing—to trade consistency for high availability and rapid response.

CAP theoremKafkaLossy Service
0 likes · 23 min read
Mask Reservation Mini‑Program: From Perfect Experience to Lossy Service – Architecture and Design
21CTO
21CTO
Apr 16, 2020 · Backend Development

How JD’s API Gateway Handles Tens of Millions of Concurrent Requests

This article explains how JD Retail built a high‑performance, secure, and observable API gateway that supports massive traffic, implements asynchronous processing for high concurrency, provides fine‑grained traffic control, gray‑release capabilities, and automated operations to serve native, web, and mini‑program clients.

api-gatewayautomationgray release
0 likes · 10 min read
How JD’s API Gateway Handles Tens of Millions of Concurrent Requests
Tencent Tech
Tencent Tech
Apr 15, 2020 · Cloud Native

How Tencent Cloud Native Development Powers High‑Concurrency Mini‑Programs

Tencent’s cloud native development platform enables mini‑programs like WeChat Reading and Maoyan Movie to handle tens of millions of daily users and billions of requests by leveraging serverless architecture, multi‑cluster deployment, automatic scaling, and extensive performance optimizations across data pipelines and underlying resources.

architecturehigh concurrencymini-programs
0 likes · 15 min read
How Tencent Cloud Native Development Powers High‑Concurrency Mini‑Programs
Senior Brother's Insights
Senior Brother's Insights
Mar 31, 2020 · Backend Development

Building a 1M‑Request Ticket‑Grab System with Go, Nginx, and Redis

This article explores how to design a high‑concurrency ticket‑booking service capable of handling millions of simultaneous requests by combining distributed load‑balancing, Nginx weighted round‑robin, Go micro‑services, and Redis atomic inventory management, complete with code samples and performance benchmarks.

GoNginxdistributed architecture
0 likes · 21 min read
Building a 1M‑Request Ticket‑Grab System with Go, Nginx, and Redis
Architecture Digest
Architecture Digest
Mar 30, 2020 · 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 overload—and presents a comprehensive backend architecture that leverages Redis clustering, dynamic URLs, Nginx load balancing, rate‑limiting, asynchronous order processing, and service degradation techniques to achieve robust, scalable performance.

Backend Architectureasynchronous processingflash sale
0 likes · 12 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
Top Architect
Top Architect
Mar 24, 2020 · Backend Development

How Meituan Built Its Distributed High‑Concurrency Instant Logistics System

This article explains how Meituan’s instant logistics platform evolved from a simple point‑to‑point delivery model to a large‑scale, AI‑driven, distributed micro‑service architecture that ensures ultra‑low latency, high availability, and cost‑effective scaling for real‑time food delivery.

AIDistributed SystemsMeituan
0 likes · 15 min read
How Meituan Built Its Distributed High‑Concurrency Instant Logistics System
Efficient Ops
Efficient Ops
Mar 18, 2020 · Operations

Why Nginx OOMs Under Million-Connection Load and How to Fix It

During a million‑connection WebSocket stress test, four 32‑core, 128 GB Nginx servers repeatedly ran out of memory, prompting an investigation that revealed oversized proxy buffers as the root cause and showed that disabling buffering and tuning buffer sizes stabilizes memory usage.

BackendOOMhigh concurrency
0 likes · 11 min read
Why Nginx OOMs Under Million-Connection Load and How to Fix It
Programmer DD
Programmer DD
Mar 17, 2020 · Backend Development

How to Keep Cache and Database Consistent Under High Concurrency?

This article explains the cache‑aside pattern, why deleting stale cache entries is preferred over updating them, outlines basic and complex cache‑database inconsistency scenarios, and presents a queue‑based solution with practical considerations for read‑blocking, request routing, and hotspot handling in high‑traffic systems.

CacheConsistencyhigh concurrency
0 likes · 11 min read
How to Keep Cache and Database Consistent Under High Concurrency?
JD Retail Technology
JD Retail Technology
Mar 12, 2020 · Backend Development

Understanding OpenResty: Architecture, Core Principles, and Real‑World Application in High‑Concurrency Systems

This article explains what OpenResty is, details its underlying Nginx‑Lua architecture—including Lua coroutines, cosocket, and multi‑stage processing—compares its performance with other web platforms, and describes its practical deployment and multi‑level caching strategy in JD.com's high‑traffic Jshop sale system.

LuaNginxOpenResty
0 likes · 12 min read
Understanding OpenResty: Architecture, Core Principles, and Real‑World Application in High‑Concurrency Systems
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 11, 2020 · Backend Development

How Alibaba Handles Million‑Ticket Flash Sales with Scalable Backend Architecture

This article explains how Alibaba's entertainment cloud platform designs layered backend architecture, hotspot data isolation, flow‑shaping funnels, multi‑level caching, and comprehensive stability measures to support ultra‑high‑concurrency ticket sales while preventing oversell and ensuring system reliability.

Backend Architectureanti‑oversellhigh concurrency
0 likes · 11 min read
How Alibaba Handles Million‑Ticket Flash Sales with Scalable Backend Architecture
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 10, 2020 · Backend Development

Comprehensive Strategies for Designing High‑Concurrency Systems

The article outlines five key layers—front‑end optimization, middle‑layer load distribution, gateway control, service‑layer improvements, and database tuning—detailing practical techniques such as static resource caching, Nginx load‑balancing methods, request rate limiting, message‑queue buffering, and extensive MySQL best‑practice guidelines to build robust high‑concurrency architectures.

Database TuningSystem Designbackend optimization
0 likes · 7 min read
Comprehensive Strategies for Designing High‑Concurrency Systems
Top Architect
Top Architect
Feb 10, 2020 · Backend Development

Design and Optimization of High‑Concurrency Flash‑Sale (秒杀) Systems

This article explains how to design a high‑performance, highly available flash‑sale system by applying dynamic/static separation, hotspot optimization, inventory reduction strategies, and comprehensive high‑availability engineering, covering both architectural principles and concrete implementation details.

System Designflash salehigh concurrency
0 likes · 27 min read
Design and Optimization of High‑Concurrency Flash‑Sale (秒杀) Systems
JD Retail Technology
JD Retail Technology
Jan 15, 2020 · Backend Development

Design and Implementation of a High‑Concurrency, Secure API Gateway at JD.com

This article outlines the background, architecture, high‑concurrency techniques, security mechanisms, gray‑release strategy, automated operations, monitoring, and fault‑diagnosis capabilities of JD.com's API gateway, demonstrating how it efficiently handles millions of concurrent requests during large‑scale shopping events.

api-gatewaygray releasehigh concurrency
0 likes · 9 min read
Design and Implementation of a High‑Concurrency, Secure API Gateway at JD.com
Python Programming Learning Circle
Python Programming Learning Circle
Jan 6, 2020 · Operations

Why 12306 Ticket System Crashes During Rush: Inside Its Massive Operational Challenges

The 12306 railway ticket platform faces extreme operational pressure because it must synchronize real‑time sales across online and offline channels, handle countless route and time combinations without buffering, manage complex inventory updates, enforce purchase limits, and process massive concurrent queries, making its load far greater than typical e‑commerce systems.

high concurrencyinventory managementreal-time data
0 likes · 7 min read
Why 12306 Ticket System Crashes During Rush: Inside Its Massive Operational Challenges
Top Architect
Top Architect
Jan 2, 2020 · Backend Development

Designing a High‑Concurrency Ticket‑Seckill System with Load Balancing, Pre‑Deduction, and Go Implementation

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.

Distributed SystemsGohigh concurrency
0 likes · 18 min read
Designing a High‑Concurrency Ticket‑Seckill System with Load Balancing, Pre‑Deduction, and Go Implementation
Programmer DD
Programmer DD
Jan 1, 2020 · Backend Development

How to Build a High‑Performance Flash Sale System: Architecture & Code

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.

Backend Architectureflash salehigh concurrency
0 likes · 14 min read
How to Build a High‑Performance Flash Sale System: Architecture & Code
Ctrip Technology
Ctrip Technology
Dec 28, 2019 · Operations

Root Cause Analysis of Dubbo Connect Timeout in High‑Concurrency Scenarios and Backlog Tuning

This article presents a detailed case study of intermittent Dubbo connect‑timeout errors in a high‑concurrency deployment, describing step‑by‑step diagnostics—from port status checks and registry verification to TCP dump analysis—and explains how adjusting the server’s backlog and accept queue resolved the SYN‑drop issue.

BacklogDubboNetwork Tuning
0 likes · 12 min read
Root Cause Analysis of Dubbo Connect Timeout in High‑Concurrency Scenarios and Backlog Tuning
ITPUB
ITPUB
Dec 28, 2019 · Backend Development

How to Build a High‑Concurrency Ticket‑Snatching System Like 12306 with Nginx, Redis, and Go

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.

GoNginxhigh concurrency
0 likes · 20 min read
How to Build a High‑Concurrency Ticket‑Snatching System Like 12306 with Nginx, Redis, and Go
Liangxu Linux
Liangxu Linux
Dec 28, 2019 · Backend Development

How to Build a Million‑User Ticket Spike System: Insights from 12306

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.

GoNginxhigh concurrency
0 likes · 21 min read
How to Build a Million‑User Ticket Spike System: Insights from 12306
Senior Brother's Insights
Senior Brother's Insights
Dec 27, 2019 · Backend Development

How to Build a High‑Performance Flash Sale System: Architecture, Strategies & Code

This article examines the challenges of designing a robust flash‑sale backend—preventing oversell, handling massive concurrent requests, securing URLs, isolating databases, and applying techniques such as Redis clustering, Nginx load balancing, rate limiting, asynchronous processing, and service degradation—to enable stable, low‑latency sales spikes.

Backend ArchitectureNginxflash sale
0 likes · 15 min read
How to Build a High‑Performance Flash Sale System: Architecture, Strategies & Code
DataFunTalk
DataFunTalk
Dec 10, 2019 · Operations

Technical Practices and Lessons from the 2019 Double‑11 Cat Night Live Event

The article details the technical goals, fairness mechanisms, high‑concurrency handling, dynamic routing, peak‑shaving, downstream protection, and on‑site screen interaction strategies used to deliver a seamless multi‑platform live‑stream experience for the Double‑11 Cat Night, while summarizing key takeaways for future large‑scale events.

Fairnesshigh concurrencylive streaming
0 likes · 12 min read
Technical Practices and Lessons from the 2019 Double‑11 Cat Night Live Event
Java Captain
Java Captain
Dec 3, 2019 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale (秒杀) System

This article examines the challenges of building a robust flash‑sale (秒杀) system—such as overselling, high concurrency, request throttling, and database design—and presents a comprehensive backend architecture using Redis clusters, Nginx, token‑bucket rate limiting, asynchronous order processing, and other optimization techniques.

backend designflash salehigh concurrency
0 likes · 14 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale (秒杀) System
Youku Technology
Youku Technology
Dec 2, 2019 · Operations

Technical Architecture and Operational Practices of Alibaba's 2019 Double‑11 "Cat Evening" Live Show

Alibaba’s 2019 Double‑11 “Cat Evening” live show combined a unified codebase across Youku, Taobao and Tmall with synchronized clocks, latency‑measurement devices and SEI‑injected messages to guarantee fair, zero‑loss interactions, while employing dynamic routing, pre‑warming, peak‑shaving, downstream protection and rehearsed contingency plans to handle massive concurrency and ensure stable, high‑quality user experience.

AlibabaFairnessOperations
0 likes · 11 min read
Technical Architecture and Operational Practices of Alibaba's 2019 Double‑11 "Cat Evening" Live Show
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 1, 2019 · Operations

How Alibaba Ensured Fair, High‑Performance Live Streaming for Double 11 Cat Night

This article details how Alibaba’s entertainment team designed and implemented a robust, cloud‑native architecture for the 2019 Double 11 “Cat Night” live‑stream, addressing technical goals, fairness, high‑concurrency spikes, dynamic routing, peak‑shaving, downstream protection, and multi‑screen interaction to deliver a seamless consumer experience.

FairnessSystem Architecturehigh concurrency
0 likes · 13 min read
How Alibaba Ensured Fair, High‑Performance Live Streaming for Double 11 Cat Night
dbaplus Community
dbaplus Community
Nov 20, 2019 · Backend Development

Designing a High‑Concurrency Ticket‑Spiking System for 1M Users and 10K Tickets

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.

Distributed SystemsGoNginx
0 likes · 20 min read
Designing a High‑Concurrency Ticket‑Spiking System for 1M Users and 10K Tickets
ITPUB
ITPUB
Nov 20, 2019 · Backend Development

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

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.

GoNginxSystem Design
0 likes · 20 min read
How to Build a Million‑User Ticket‑Spike System with Nginx, Go, and Redis
Architecture Digest
Architecture Digest
Nov 20, 2019 · Backend Development

Design Principles and Optimization Strategies for High‑Concurrency Flash‑Sale (Seckill) Systems

This article examines the architectural design of flash‑sale (seckill) systems, covering high performance through dynamic‑static separation, hotspot optimization, consistency handling for inventory deduction, and high‑availability techniques such as traffic shaping, queuing, and fallback plans.

ConsistencySeckillarchitecture
0 likes · 30 min read
Design Principles and Optimization Strategies for High‑Concurrency Flash‑Sale (Seckill) Systems
MaGe Linux Operations
MaGe Linux Operations
Nov 19, 2019 · Backend Development

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

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, Go‑based local stock deduction, Redis‑backed unified inventory control, and performance testing with ApacheBench to achieve stable, scalable ticket sales during peak demand.

Gohigh concurrencyload balancing
0 likes · 19 min read
How to Build a Million‑User Ticket‑Spike System with Nginx, Go, and Redis
Mafengwo Technology
Mafengwo Technology
Nov 14, 2019 · Backend Development

How MaFengWo Built a Scalable Marketing Platform for Double‑11: Architecture Insights

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.

Marketinghigh concurrencyplatform architecture
0 likes · 17 min read
How MaFengWo Built a Scalable Marketing Platform for Double‑11: Architecture Insights
Java Captain
Java Captain
Nov 14, 2019 · Backend Development

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

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.

Godistributed architecturehigh concurrency
0 likes · 20 min read
Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation
Programmer DD
Programmer DD
Nov 7, 2019 · Backend Development

How to Build a High‑Concurrency Ticket‑Spike System with Go, Nginx, and Redis

This article dissects the extreme concurrency challenges of China's 12306 ticket‑spike scenario, presents a layered load‑balancing architecture, compares order‑processing strategies, and provides a complete Go‑based prototype with Nginx weighted routing and Redis atomic stock deduction, complete with performance testing and key takeaways.

GoNginxhigh concurrency
0 likes · 19 min read
How to Build a High‑Concurrency Ticket‑Spike System with Go, Nginx, and Redis
Youku Technology
Youku Technology
Nov 5, 2019 · Backend Development

Traffic Shaping Strategies for High‑Concurrency Events: Staggering, Rate Limiting, and Peak Cutting

The article explains how Youku’s engineers mitigate extreme traffic spikes during large‑scale events by applying three core techniques—staggering requests across time, enforcing client‑side rate limits, and cutting peaks through minimum intervals, probabilistic sending and fairness algorithms—to lower maximum QPS, improve stability, and preserve user experience.

QPSScalabilityTraffic Shaping
0 likes · 8 min read
Traffic Shaping Strategies for High‑Concurrency Events: Staggering, Rate Limiting, and Peak Cutting
Architect's Tech Stack
Architect's Tech Stack
Nov 4, 2019 · Backend Development

Design and Implementation of a High‑Concurrency Ticket Seckill System Using Go, Nginx, and Redis

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.

GoNginxSeckill
0 likes · 18 min read
Design and Implementation of a High‑Concurrency Ticket Seckill System Using Go, Nginx, and Redis
Big Data Technology & Architecture
Big Data Technology & Architecture
Oct 31, 2019 · Backend Development

Designing a High-Concurrency Flash Sale System Using Redis Caching and Lua Scripts

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.

Backend ArchitectureLuaMessage Queue
0 likes · 8 min read
Designing a High-Concurrency Flash Sale System Using Redis Caching and Lua Scripts
Java Backend Technology
Java Backend Technology
Oct 29, 2019 · Backend Development

How to Build a Million‑User Ticket‑Spiking System with Nginx, Go, and Redis

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.

GoNginxhigh concurrency
0 likes · 20 min read
How to Build a Million‑User Ticket‑Spiking System with Nginx, Go, and Redis
Tencent Cloud Developer
Tencent Cloud Developer
Oct 25, 2019 · Backend Development

High-Concurrency Practices for Tencent Video Front-End Node.js Services

Tencent Video’s front‑end Node.js services achieve massive concurrency stability through a layered architecture that combines GSLB‑directed CDN, TGW, Nginx, and clustered workers, reinforced by process guardians, three‑tier disaster‑recovery fallbacks, multi‑level caching with lock mechanisms, and comprehensive logging and alerting.

AvailabilityNode.jshigh concurrency
0 likes · 11 min read
High-Concurrency Practices for Tencent Video Front-End Node.js Services
Big Data Technology Architecture
Big Data Technology Architecture
Oct 17, 2019 · Backend Development

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

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.

GoNginxhigh concurrency
0 likes · 19 min read
Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation
21CTO
21CTO
Oct 14, 2019 · Backend Development

How to Build a Million‑User Ticket‑Snatching System with Nginx, Go, and Redis

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.

GoNginxhigh concurrency
0 likes · 18 min read
How to Build a Million‑User Ticket‑Snatching System with Nginx, Go, and Redis
dbaplus Community
dbaplus Community
Oct 9, 2019 · Backend Development

How to Design a High‑Throughput Lottery System: Load‑Balancing, Redis, and Tomcat Tuning

This article explains how to handle massive, bursty traffic in lottery‑style applications by designing a load‑balancing layer that filters invalid requests, optimizing Tomcat thread pools, and moving core business logic to Redis while using message queues to smooth gift‑distribution spikes.

System ArchitectureTomcathigh concurrency
0 likes · 12 min read
How to Design a High‑Throughput Lottery System: Load‑Balancing, Redis, and Tomcat Tuning
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 23, 2019 · Backend Development

Mastering High-Concurrency Technical Architecture: Core Principles and Solutions

This article explains what technical architecture is, breaks down its three core components—business technical problems, technical solutions, and technical components—and then dives deep into high‑concurrency challenges, systematic thinking methods, and practical approaches such as resource scaling, stateless design, load balancing, caching, and I/O optimization.

Backend ArchitectureDistributed SystemsScalability
0 likes · 12 min read
Mastering High-Concurrency Technical Architecture: Core Principles and Solutions
Architect's Tech Stack
Architect's Tech Stack
Sep 12, 2019 · Backend Development

Design and Implementation of a Short URL Service in Java

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.

Backendhigh concurrencyredis
0 likes · 8 min read
Design and Implementation of a Short URL Service in Java
Sohu Tech Products
Sohu Tech Products
Sep 11, 2019 · Backend Development

Design and Implementation of a High‑Concurrency Flash‑Sale System for Online Real‑Estate Opening

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.

Backend ArchitectureDistributed SystemsKafka
0 likes · 12 min read
Design and Implementation of a High‑Concurrency Flash‑Sale System for Online Real‑Estate Opening
21CTO
21CTO
Sep 6, 2019 · Backend Development

Mastering Cache Reads: Prevent Cache Penetration and Expiration in High‑Concurrency Systems

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.

BackendPHPcache expiration
0 likes · 5 min read
Mastering Cache Reads: Prevent Cache Penetration and Expiration in High‑Concurrency Systems
Programmer DD
Programmer DD
Aug 24, 2019 · Backend Development

How to Solve Cache‑Database Consistency Issues in High‑Concurrency Systems

This article examines common cache‑database consistency problems, explains why naive double‑write approaches fail, introduces the Cache‑Aside pattern, and proposes a queue‑based serialization solution with lazy cache updates to maintain data integrity under high‑traffic, concurrent read‑write workloads.

BackendCacheConsistency
0 likes · 12 min read
How to Solve Cache‑Database Consistency Issues in High‑Concurrency Systems
MXPlayer Technical Team
MXPlayer Technical Team
Aug 10, 2019 · Cloud Computing

How to Build a Low‑Cost, High‑Concurrency Distributed Video Transcoding System on AWS

This article explains the design of a distributed video transcoding platform that leverages AWS Lambda and EC2‑SLAVE to achieve high‑concurrency, low‑latency streaming, detailing architecture, load balancing, health checks, task monitoring, and cost‑saving strategies for scalable cloud‑based video processing.

AWS LambdaCost OptimizationVideo Transcoding
0 likes · 18 min read
How to Build a Low‑Cost, High‑Concurrency Distributed Video Transcoding System on AWS
Java Captain
Java Captain
Jul 30, 2019 · Backend Development

Design and Implementation of a High‑Concurrency Seckill Architecture Using Spring Boot

This article presents a comprehensive design for a flash‑sale (seckill) system that handles massive simultaneous requests by combining load balancing, distributed locking, message queues, cache strategies, and fault‑tolerant deployment, and includes a complete Spring Boot code example with detailed architectural diagrams.

Backend ArchitectureSeckillhigh concurrency
0 likes · 7 min read
Design and Implementation of a High‑Concurrency Seckill Architecture Using Spring Boot
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 23, 2019 · Backend Development

Designing Ultra‑Fast High‑Concurrency Systems: Principles and a 60k QPS Flash‑Sale Case Study

This article outlines core principles for building high‑concurrency back‑end systems—doing less and doing it cleverly—then demonstrates their application in a real‑world flash‑sale (秒杀) scenario that handled 60,000 queries per second through careful feature selection, data reduction, caching strategies, queue control, and asynchronous processing.

Backend PerformanceSystem Designcaching
0 likes · 18 min read
Designing Ultra‑Fast High‑Concurrency Systems: Principles and a 60k QPS Flash‑Sale Case Study
Big Data Technology & Architecture
Big Data Technology & Architecture
Jul 20, 2019 · Databases

Understanding Redis: Purpose, Usage, Caching Benefits, Differences with Memcached, and Thread Model

This article explains what Redis is, how it is used for caching in projects, the performance and concurrency advantages of caching, common cache pitfalls, key differences between Redis and Memcached, and the internal single‑threaded event‑driven architecture that enables high‑throughput operations.

In-Memory DatabaseMemcachedThread Model
0 likes · 11 min read
Understanding Redis: Purpose, Usage, Caching Benefits, Differences with Memcached, and Thread Model
21CTO
21CTO
Jul 7, 2019 · Backend Development

How to Prevent Cache‑Database Consistency Issues in High‑Concurrency Systems

This article explains why cache‑database double‑write introduces consistency problems, introduces the Cache‑Aside pattern and lazy‑loading strategy, and proposes a queue‑based serialization approach to safely handle updates and reads in high‑concurrency backend systems.

Cache Consistencycache-asidehigh concurrency
0 likes · 10 min read
How to Prevent Cache‑Database Consistency Issues in High‑Concurrency Systems
Java Captain
Java Captain
Jun 28, 2019 · Backend Development

Understanding High Concurrency: CPU Utilization, Context Switching, and Performance Comparison of PHP Swoole vs Java Netty

This article explains that high concurrency is fundamentally about efficiently squeezing CPU resources, discusses the evolution of concurrency models, presents a control‑variable analysis of HTTP request flow, and compares PHP‑Swoole with Java‑Netty through detailed benchmark results and code examples.

Java NettyPHP SwoolePerformance Testing
0 likes · 13 min read
Understanding High Concurrency: CPU Utilization, Context Switching, and Performance Comparison of PHP Swoole vs Java Netty
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 26, 2019 · Operations

Understanding High Concurrency: Definition, Key Metrics, and Relationship with Multithreading

High concurrency refers to a short period where a system receives a massive number of requests, such as ticket‑booking spikes, and is measured by metrics like response time, throughput, QPS, and concurrent users, while multithreading is merely one programming technique to handle such load, not synonymous with high concurrency.

Response TimeThroughputhigh concurrency
0 likes · 3 min read
Understanding High Concurrency: Definition, Key Metrics, and Relationship with Multithreading
dbaplus Community
dbaplus Community
Jun 12, 2019 · Backend Development

16 Proven Strategies to Design High‑Concurrency Systems for Stability and Scale

This article outlines sixteen practical techniques—from reducing request volume and merging calls to leveraging caching, async processing, sharding, load balancing, and circuit breaking—to help engineers design high‑concurrency architectures that remain stable, performant, and easily scalable under extreme traffic conditions.

Circuit BreakingSystem Designcaching
0 likes · 23 min read
16 Proven Strategies to Design High‑Concurrency Systems for Stability and Scale
Architect's Tech Stack
Architect's Tech Stack
Jun 8, 2019 · Operations

Designing High‑Concurrency Server Architecture: Load Balancing, Clustering, Caching, and Asynchronous Processing

The article explains how to design a high‑concurrency server architecture—including load balancing, database master‑slave clusters, NoSQL caching, CDN static assets, concurrency testing, message queues, tiered caching, and automated redundancy—to keep large‑scale e‑commerce services responsive and reliable under heavy user traffic.

Server Architecturehigh concurrency
0 likes · 21 min read
Designing High‑Concurrency Server Architecture: Load Balancing, Clustering, Caching, and Asynchronous Processing
dbaplus Community
dbaplus Community
Jun 5, 2019 · Databases

How to Scale SQL Databases for 20,000+ Concurrent Users: Single Instance, Sharding, and Read‑Write Separation

This article explains how to handle 20,000+ concurrent SQL requests by moving from a simple single‑instance setup to multi‑instance sharding and finally to read‑write separation, detailing the architectural decisions, routing algorithms, and practical limits for high‑traffic e‑commerce systems.

high concurrencyperformanceread-write separation
0 likes · 7 min read
How to Scale SQL Databases for 20,000+ Concurrent Users: Single Instance, Sharding, and Read‑Write Separation
21CTO
21CTO
May 30, 2019 · Backend Development

How Weibo Handles Billion‑Scale Short Video Traffic: High‑Concurrency Architecture Deep Dive

This article explains how Weibo's video team designs a highly available, high‑concurrency architecture for short‑video services, covering team responsibilities, business scenarios, microservice design, caching layers, multi‑data‑center HA, and circuit‑breaker mechanisms to sustain unpredictable traffic spikes.

BackendHAMicroservices
0 likes · 12 min read
How Weibo Handles Billion‑Scale Short Video Traffic: High‑Concurrency Architecture Deep Dive
Architecture Digest
Architecture Digest
May 29, 2019 · Backend Development

Design and Solutions for High Availability and High Concurrency in Weibo Short Video Service

The article presents a detailed analysis of Weibo's short‑video platform architecture, covering team background, business scenarios, micro‑service design, feed‑pull model, multi‑level distributed caching, multi‑datacenter HA deployment, circuit‑breaker mechanisms, and elastic scaling to achieve high availability under unpredictable traffic spikes.

Backend ArchitectureWeibodistributed cache
0 likes · 12 min read
Design and Solutions for High Availability and High Concurrency in Weibo Short Video Service
Java Captain
Java Captain
May 19, 2019 · Backend Development

Flash Sale (Seckill) System Design and Technical Challenges

This article analyzes the business flow of flash‑sale (seckill) activities, identifies the high‑concurrency technical challenges, and presents a comprehensive backend architecture—including frontend static page handling, request throttling, service‑layer queuing, database sharding, caching, optimistic locking, and anti‑cheating measures—to ensure reliability, scalability, and data consistency.

Backend Architecturedatabase shardingflash sale
0 likes · 33 min read
Flash Sale (Seckill) System Design and Technical Challenges
21CTO
21CTO
Apr 15, 2019 · Big Data

Mastering High‑Concurrency Big Data: Sharding, Partitioning, and Index Strategies

This article explores practical techniques for handling massive, high‑concurrency data workloads, covering relational database limits, read/write separation, vertical and horizontal sharding, key selection, archival to NoSQL stores, and the use of heterogeneous index tables to maintain performance.

Big DataPartitioningdatabase scaling
0 likes · 6 min read
Mastering High‑Concurrency Big Data: Sharding, Partitioning, and Index Strategies
Architecture Digest
Architecture Digest
Apr 2, 2019 · Databases

Designing Scalable Database Architecture for High‑Concurrency Systems

This article explains how to design a database architecture that can handle millions of daily active users and tens of thousands of concurrent requests by using multi‑server sharding, extensive table partitioning, read‑write separation, and distributed unique‑ID generation techniques such as Snowflake.

Read-Write SeparationSnowflake IDdatabase sharding
0 likes · 20 min read
Designing Scalable Database Architecture for High‑Concurrency Systems
JD Tech Talk
JD Tech Talk
Mar 27, 2019 · Backend Development

Design and Key Considerations of JD Digits' Accounting Settlement System

This article explains the responsibilities, architectural design, critical construction points, functional modules, hotspot account handling, database sharding strategies, and diverse settlement rule implementations of JD Digits' accounting and settlement system, which is the core financial control component of the payment platform.

Backendaccountingdatabase sharding
0 likes · 10 min read
Design and Key Considerations of JD Digits' Accounting Settlement System
Architects' Tech Alliance
Architects' Tech Alliance
Mar 14, 2019 · Backend Development

Understanding Distributed Systems, High Concurrency, and Multithreading in Java

This article explains the distinct concepts of distributed systems, high concurrency, and multithreading, clarifies their relationships, describes horizontal scaling and vertical splitting, and outlines how these techniques are applied in Java backend development while also promoting a free Java interview series.

backend-developmenthigh concurrencyjava
0 likes · 5 min read
Understanding Distributed Systems, High Concurrency, and Multithreading in Java
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 9, 2019 · Backend Development

Boost High-Concurrency Performance with Request Merging in Java

By introducing request merging and batch APIs, this article demonstrates how to improve high‑concurrency performance in Java backend services, detailing the design, data structures, scheduled execution, and code implementation while discussing trade‑offs and practical considerations.

Java concurrencybatch APIhigh concurrency
0 likes · 8 min read
Boost High-Concurrency Performance with Request Merging in Java
21CTO
21CTO
Feb 15, 2019 · Backend Development

Mastering High‑Concurrency Flash Sales: Preventing System Collapse

This article examines the technical challenges of handling massive concurrent traffic during flash‑sale events, explains why backend APIs become bottlenecks, and presents practical strategies—including request design, overload protection, anti‑abuse measures, and data‑safety techniques such as pessimistic, FIFO, and optimistic locking—to keep web systems stable and performant.

Data Safetybackend optimizationflash sale
0 likes · 16 min read
Mastering High‑Concurrency Flash Sales: Preventing System Collapse
Didi Tech
Didi Tech
Jan 15, 2019 · Backend Development

DDMQ: Didi's Open‑Source Distributed Message Queue

Didi Mobility has open‑sourced DDMQ, an enterprise‑grade distributed message queue that delivers millisecond‑level latency and millions of messages per second, supports real‑time, delayed and transactional messages via RocketMQ/Kafka and RocksDB, offers multi‑language SDKs, flexible consumption, server‑side filtering, a unified console, and achieves five‑nine availability across Didi’s ride‑hailing, finance and delivery platforms.

DDMQDistributed MessagingMessage Queue
0 likes · 7 min read
DDMQ: Didi's Open‑Source Distributed Message Queue
Java High-Performance Architecture
Java High-Performance Architecture
Jan 15, 2019 · Backend Development

7 Essential Strategies to Build High‑Concurrency Back‑End Systems

Designing high‑concurrency applications requires adopting stateless services, modular decomposition, service‑oriented architecture, message queues, data heterogeneity handling, multi‑layer caching, and parallel processing, each illustrated with practical e‑commerce examples that balance scalability, fault tolerance, and eventual consistency.

Backend ArchitectureMicroservicesScalability
0 likes · 7 min read
7 Essential Strategies to Build High‑Concurrency Back‑End Systems
21CTO
21CTO
Jan 14, 2019 · Backend Development

How SuNing Financial Scaled Its Red Envelope System for Billion-User Peaks

This article details SuNing Financial’s red‑envelope platform architecture and evolution, covering high‑concurrency challenges, traffic shaping, asynchronous processing, multi‑level caching, Redis‑based distributed locks, task scheduling, payment‑chain isolation, high‑availability deployment, multi‑layer flow control, monitoring, and future scalability directions.

Distributed LocksMicroservicescaching
0 likes · 14 min read
How SuNing Financial Scaled Its Red Envelope System for Billion-User Peaks
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 28, 2018 · Backend Development

Traffic Peak Shaving: Origins and Implementation Strategies for High‑Concurrency Scenarios

The article explains why traffic peak shaving is needed in high‑concurrency situations such as flash sales, and describes practical solutions including message‑queue buffering and multi‑layer funnel filtering, along with caching and CDN techniques to protect backend systems.

Traffic Shapingfunnel filteringhigh concurrency
0 likes · 6 min read
Traffic Peak Shaving: Origins and Implementation Strategies for High‑Concurrency Scenarios