BestHub
Sign in
Tagged articles
757 articles
Page 2 of 8
Su San Talks Tech
Su San Talks Tech
Aug 25, 2025 · Backend Development

How to Build a High‑Concurrency Queue System with OpenResty, Lua, and Redis

This article analyzes current system performance bottlenecks, compares hard‑rate‑limiting and flexible queuing strategies, and presents a non‑intrusive traffic‑control solution built with OpenResty+Lua and Redis that offers zero‑code changes, high performance, scalability, and real‑time visual feedback for high‑concurrency scenarios.

LuaOpenRestyRate Limiting
0 likes · 18 min read
How to Build a High‑Concurrency Queue System with OpenResty, Lua, and Redis
Cognitive Technology Team
Cognitive Technology Team
Aug 25, 2025 · Backend Development

Why epoll Uses Red-Black Trees for High-Performance Linux Networking

epoll, Linux’s high-performance I/O multiplexing mechanism, outperforms select and poll by leveraging a red-black tree to manage file descriptors, offering O(log n) registration, O(1) event retrieval, and scalable handling of millions of connections, with detailed explanations of its architecture, workflow, and performance advantages.

I/O MultiplexingLinuxRed-Black Tree
0 likes · 10 min read
Why epoll Uses Red-Black Trees for High-Performance Linux Networking
FunTester
FunTester
Aug 24, 2025 · Backend Development

How to Tackle the C10K Challenge: High‑Concurrency Tips for Java/Netty Servers

This article explains the C10K problem and provides practical, non‑blocking and reactive strategies, thread‑count minimization, Netty configuration, memory management, and emerging technologies like GraalVM Native‑Image and Project Loom to keep Java servers stable under massive concurrent connections.

C10KJava performanceNetty
0 likes · 10 min read
How to Tackle the C10K Challenge: High‑Concurrency Tips for Java/Netty Servers
mikechen
mikechen
Aug 6, 2025 · Big Data

How to Diagnose and Fix Kafka Message Backlog in High‑Concurrency Environments

In high‑concurrency systems, Kafka message backlog occurs when producers outpace consumers, leading to unprocessed messages that threaten stability and real‑time performance, and this article explains the root causes and provides practical producer‑side and consumer‑side optimization techniques to resolve the issue.

Batch ProcessingRate Limitingconsumer optimization
0 likes · 5 min read
How to Diagnose and Fix Kafka Message Backlog in High‑Concurrency Environments
MaGe Linux Operations
MaGe Linux Operations
Aug 6, 2025 · Operations

Master Linux Network Performance: Practical TCP/IP Stack Tuning Guide

This comprehensive guide explains why network performance becomes a bottleneck in high‑traffic environments and provides step‑by‑step Linux TCP/IP and IP stack parameter optimizations, high‑concurrency tuning, monitoring scripts, and real‑world e‑commerce case results to dramatically improve throughput and latency.

TCP/IP Tuninghigh concurrencynetwork performance
0 likes · 14 min read
Master Linux Network Performance: Practical TCP/IP Stack Tuning Guide
TAL Education Technology
TAL Education Technology
Jul 7, 2025 · Backend Development

How a Scalable Data Dashboard Handles 500+ Real-Time Screens with Millisecond Latency

This article details the design and implementation of a high‑performance data‑screen platform, covering its background, functional matrix, cloud‑native architecture, caching strategies, resource isolation, load testing, and monitoring, and demonstrates how it supports over 500 concurrent screens with sub‑second response times for enterprise decision‑making.

Backend ArchitectureCachingData visualization
0 likes · 11 min read
How a Scalable Data Dashboard Handles 500+ Real-Time Screens with Millisecond Latency
Deepin Linux
Deepin Linux
Jul 5, 2025 · Backend Development

Mastering High-Concurrency C++ Servers: Multithreaded Network Programming Explained

This comprehensive guide explores C++ multithreaded network programming for high‑concurrency servers, covering threads, processes, socket basics, TCP/UDP protocols, thread pools, synchronization primitives, lock‑free structures, I/O multiplexing techniques, and a practical high‑performance chat server implementation.

C++I/O MultiplexingSocket
0 likes · 54 min read
Mastering High-Concurrency C++ Servers: Multithreaded Network Programming Explained
Su San Talks Tech
Su San Talks Tech
Jun 23, 2025 · Backend Development

How to Build a Million‑QPS Short‑URL Service: Architecture & Code

This article walks through the challenges of handling millions of requests per second for a short‑URL service and presents a complete backend solution—including ID generation, Base62 encoding, cache‑layer design, Nginx redirect optimization, disaster‑recovery strategies, sharding, and performance test results—while providing Java code snippets and design principles for high‑throughput, resilient systems.

JavaSystem architecturehigh concurrency
0 likes · 11 min read
How to Build a Million‑QPS Short‑URL Service: Architecture & Code
Deepin Linux
Deepin Linux
Jun 21, 2025 · Backend Development

Unlocking High-Concurrency in C/C++: A Deep Dive into Coroutines and Their Implementation

This comprehensive guide explores how coroutines provide a lightweight, lock‑free alternative to traditional threads for high‑concurrency C/C++ server programming, covering their fundamentals, differences from threads, implementation techniques, context switching, scheduler design, epoll integration, timer management, and performance testing.

C++Schedulerasynchronous I/O
0 likes · 57 min read
Unlocking High-Concurrency in C/C++: A Deep Dive into Coroutines and Their Implementation
Architect
Architect
Jun 19, 2025 · Backend Development

How to Tune Nginx for Million‑Level Concurrency: Key Optimizations

This article explains how to configure Nginx and the underlying Linux system to handle millions of concurrent connections by optimizing the I/O model with epoll, scaling worker processes, enabling zero‑copy sendfile, using gzip compression, and tuning kernel parameters and CPU affinity.

Backend DevelopmentLinuxhigh concurrency
0 likes · 11 min read
How to Tune Nginx for Million‑Level Concurrency: Key Optimizations
DaTaobao Tech
DaTaobao Tech
Jun 18, 2025 · Backend Development

How to Eliminate GC Pauses in High‑QPS Java Services: A Step‑by‑Step JVM Tuning Guide

This article investigates a high‑concurrency Java service that suffers from long GC pauses during large index swaps, identifies YGC Object Copy as the root cause, and presents a series of JVM tuning techniques—including MaxTenuringThreshold, InitialTenuringThreshold, AlwaysTenure, G1HeapRegionSize, ZGC, and an Eden‑preheat strategy—to achieve near‑zero service disruption and 99.995% success rate.

GC tuningGray ReleaseJVM
0 likes · 20 min read
How to Eliminate GC Pauses in High‑QPS Java Services: A Step‑by‑Step JVM Tuning Guide
Senior Tony
Senior Tony
Jun 18, 2025 · Backend Development

Mastering High‑Concurrency Account Balance Deductions with Kafka, Sharding, and Parallel Processing

This article examines the challenges of high‑concurrency write scenarios in ad‑billing systems, explains why row‑level locking becomes a bottleneck, and presents a step‑by‑step solution using Kafka for asynchronous peak shaving, parallel consumer processing, database sharding, hotspot dispersion, and batch deduction to achieve reliable real‑time balance updates.

KafkaShardingaccount balance deduction
0 likes · 8 min read
Mastering High‑Concurrency Account Balance Deductions with Kafka, Sharding, and Parallel Processing
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 3, 2025 · Big Data

Kafka High-Concurrency Core Design Explained

This article explains how Kafka achieves high concurrency through its distributed broker cluster, partitioned topics, sequential log writes, message compression, asynchronous producer mechanisms, and OS page‑cache techniques, illustrating the combined architectural and performance optimizations that enable massive throughput.

Kafkaasynchronous producerdistributed architecture
0 likes · 4 min read
Kafka High-Concurrency Core Design Explained
MaGe Linux Operations
MaGe Linux Operations
May 26, 2025 · Operations

Master Linux Network Tuning for Million‑Connection High Concurrency

This guide walks through real‑world Linux high‑concurrency scenarios, diagnosing TCP state bottlenecks, analyzing default kernel parameters, and applying practical sysctl tweaks, queue and buffer optimizations, keepalive settings, and monitoring scripts to dramatically improve connection handling and throughput.

Network TuningTCP Optimizationhigh concurrency
0 likes · 9 min read
Master Linux Network Tuning for Million‑Connection High Concurrency
Architect
Architect
May 16, 2025 · Industry Insights

How to Master High‑Concurrency Flash‑Sale Systems with Redis, MQ, and Inventory Hint

This article analyzes the challenges of e‑commerce flash‑sale spikes and presents four proven architectural patterns—pressure distribution, Redis + MQ, Inventory Hint, and their combined use—detailing their principles, Lua scripts, transaction messaging, and practical trade‑offs for building resilient, high‑throughput systems.

Backend ArchitectureInventory HintMQ
0 likes · 15 min read
How to Master High‑Concurrency Flash‑Sale Systems with Redis, MQ, and Inventory Hint
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
May 15, 2025 · Operations

Nginx High-Concurrency Optimization Techniques

This article explains how to achieve million‑level concurrent connections with Nginx by tuning OS limits, worker processes, epoll event handling, gzip compression, and zero‑copy file transfer, providing concrete configuration snippets and performance rationale for each optimization.

LinuxOptimizationepoll
0 likes · 4 min read
Nginx High-Concurrency Optimization Techniques
macrozheng
macrozheng
May 12, 2025 · Backend Development

Designing a Billion‑User Real‑Time Leaderboard: Redis vs MySQL

This article explores how to build a scalable, high‑performance leaderboard for hundreds of millions of users by comparing traditional database ORDER BY approaches with Redis sorted sets, addressing challenges such as hot keys, memory pressure, persistence risks, and presenting a divide‑and‑conquer implementation strategy.

Scalabilitybig-datahigh concurrency
0 likes · 11 min read
Designing a Billion‑User Real‑Time Leaderboard: Redis vs MySQL
Deepin Linux
Deepin Linux
Apr 25, 2025 · Backend Development

Understanding epoll: Linux I/O Multiplexing, Design, and Practical Usage

This article explains the limitations of traditional I/O models, introduces epoll as a high‑performance Linux I/O multiplexing mechanism, details its design principles, API usage, kernel data structures, and provides practical coding examples and optimization tips for building scalable backend services.

Event-drivenI/O Multiplexingepoll
0 likes · 41 min read
Understanding epoll: Linux I/O Multiplexing, Design, and Practical Usage
IT Services Circle
IT Services Circle
Apr 18, 2025 · Backend Development

Preventing Duplicate Orders under 100k QPS: Full‑Stack Strategies

This article explains how to prevent duplicate orders in a high‑traffic system handling 100,000 QPS by combining frontend safeguards such as button disabling and token mechanisms with backend techniques including NGINX rate limiting, gateway token validation, idempotent database design, sharding, distributed locks, optimistic locking, and comprehensive logging and monitoring.

IdempotencyRate Limitingbackend design
0 likes · 7 min read
Preventing Duplicate Orders under 100k QPS: Full‑Stack Strategies
Deepin Linux
Deepin Linux
Apr 18, 2025 · Backend Development

Deep Dive into Linux epoll: Design, Implementation, and Performance

epoll is a high‑performance Linux I/O multiplexing mechanism that replaces select/poll by using an event‑driven design with a red‑black tree and ready list, supporting edge‑ and level‑triggered modes, efficient data transfer via mmap, and providing superior scalability for high‑concurrency network applications.

Event-drivenI/O Multiplexingepoll
0 likes · 85 min read
Deep Dive into Linux epoll: Design, Implementation, and Performance
Java Tech Enthusiast
Java Tech Enthusiast
Apr 11, 2025 · Backend Development

Ensuring Message Processing Once in High-Concurrency Scenarios

The article explains how to guarantee that messages are processed only once in high‑concurrency environments by combining production‑side idempotent publishing, broker‑level deduplication with unique IDs, and consumption‑side business idempotency such as database constraints or distributed locks, while also recommending monitoring, metrics, and reconciliation as safety nets.

Distributed SystemsIdempotencyRocketMQ
0 likes · 6 min read
Ensuring Message Processing Once in High-Concurrency Scenarios
Java Captain
Java Captain
Apr 4, 2025 · Backend Development

High Concurrency: Principles, Impacts, and Practical Solutions for Backend Systems

This comprehensive guide explains the nature of high concurrency, distinguishes it from parallelism, outlines its potential consequences across application, database, and service layers, and presents a systematic set of mitigation strategies—including rate limiting, asynchronous processing, redundancy, caching, and queue‑based designs—supported by real‑world case studies and code examples.

Backend PerformanceCachingDatabase Optimization
0 likes · 27 min read
High Concurrency: Principles, Impacts, and Practical Solutions for Backend Systems
IT Architects Alliance
IT Architects Alliance
Apr 2, 2025 · Backend Development

Designing High‑Concurrency Backend Architecture for E‑commerce Platforms

The article explains how to design a scalable, highly available backend system capable of handling millions of requests per second by defining key performance metrics, estimating traffic with the 2/8 rule, and applying architectural patterns such as load‑balanced clusters, vertical service splitting, distributed caching, and database master‑slave replication, illustrated with a Taobao case study.

Backend ArchitectureDistributed Cachedatabase replication
0 likes · 14 min read
Designing High‑Concurrency Backend Architecture for E‑commerce Platforms
Cognitive Technology Team
Cognitive Technology Team
Mar 24, 2025 · Fundamentals

Understanding Sockets and epoll: Kernel Abstractions and High‑Concurrency Design

Socket provides a file‑descriptor based network communication abstraction in the OS, while epoll uses a red‑black‑tree and ready‑queue mechanism to deliver O(log N) scalable I/O event handling, together forming the core design that enables high‑concurrency servers to efficiently manage thousands of connections.

IO MultiplexingSocketepoll
0 likes · 7 min read
Understanding Sockets and epoll: Kernel Abstractions and High‑Concurrency Design
Bilibili Tech
Bilibili Tech
Mar 18, 2025 · Operations

Technical Practices for Ensuring Stability of Bilibili’s 2025 Spring Festival Gala Live Stream

Bilibili’s engineering team built a scenario‑metadata and one‑click fault‑drill platform, implemented multi‑tier degradation, dynamic capacity planning, and extensive automated fault‑injection testing to guarantee zero‑severity incidents during the high‑traffic 2025 Spring Festival Gala live stream.

Fault InjectionOperationshigh concurrency
0 likes · 16 min read
Technical Practices for Ensuring Stability of Bilibili’s 2025 Spring Festival Gala Live Stream
Sanyou's Java Diary
Sanyou's Java Diary
Mar 17, 2025 · Backend Development

Mastering Flash Sale Scalability: Redis, MQ, and Inventory Hint Strategies

This article explores industry‑proven techniques for handling massive flash‑sale traffic, covering pressure‑distribution, Redis + MQ combos, Lua‑based stock deduction, RocketMQ transactional messages, and Alibaba Cloud's Inventory Hint to ensure consistency and performance under extreme concurrency.

Inventory HintLua ScriptMessage Queue
0 likes · 14 min read
Mastering Flash Sale Scalability: Redis, MQ, and Inventory Hint Strategies
Bilibili Tech
Bilibili Tech
Mar 14, 2025 · Backend Development

Evolution and Optimization of Bilibili Membership Ticketing System for High‑Concurrency Scenarios

Bilibili’s ticketing platform evolved from a single‑transaction, synchronous design to an asynchronous batch system and finally to a Redis‑cached inventory layer, adding DB isolation changes, sharding, bloom‑filter protection and adaptive rate limiting, which together enabled handling up to 930 k requests per second and stable high‑concurrency ticket sales.

asynchronous processingbackend optimizationdatabase isolation
0 likes · 18 min read
Evolution and Optimization of Bilibili Membership Ticketing System for High‑Concurrency Scenarios
Architecture Digest
Architecture Digest
Mar 12, 2025 · Backend Development

Designing and Optimizing a High‑Concurrency Counting System for Large‑Scale Social Media

This article explains the challenges of storing and serving trillion‑level count data for a massive micro‑blogging platform and presents a step‑by‑step backend design that evolves from simple MySQL tables to sharded databases, Redis caching, message‑queue write‑sharding, and memory‑efficient custom data structures to achieve high performance, low cost, and strong consistency.

MySQLPerformance OptimizationSharding
0 likes · 12 min read
Designing and Optimizing a High‑Concurrency Counting System for Large‑Scale Social Media
Deepin Linux
Deepin Linux
Feb 6, 2025 · Backend Development

A Comprehensive Guide to epoll in Linux: Principles, Design, and Practical Usage

This article explains how epoll improves Linux I/O multiplexing by using red‑black trees and ready lists, compares level‑triggered and edge‑triggered modes, details the epoll_create/epoll_ctl/epoll_wait system calls, discusses common pitfalls, and provides a complete TCP server example for handling many concurrent connections.

I/O MultiplexingLinuxedge-triggered
0 likes · 72 min read
A Comprehensive Guide to epoll in Linux: Principles, Design, and Practical Usage
Architect's Guide
Architect's Guide
Jan 24, 2025 · Backend Development

How to Design a High-Concurrency System: Key Architectural Strategies for Interviews

This article explains how to answer interview questions about designing high‑concurrency systems by outlining essential architectural techniques such as system decomposition, caching, message queues, database sharding, read‑write separation, and Elasticsearch, while emphasizing practical considerations and real‑world complexity.

System Designdatabase shardinghigh concurrency
0 likes · 9 min read
How to Design a High-Concurrency System: Key Architectural Strategies for Interviews
Linux Cloud Computing Practice
Linux Cloud Computing Practice
Jan 23, 2025 · Backend Development

Why Nginx Is the Go‑to Choice for High‑Performance Web and Proxy Services

This article explains Nginx’s key advantages—high‑concurrency handling, efficient load balancing, versatile mail proxying, simple installation and zero‑downtime upgrades—illustrates its architecture with master/worker processes, and outlines essential configuration topics from basic setup to advanced HTTPS and reverse‑proxy techniques.

HTTPSWeb serverconfiguration
0 likes · 7 min read
Why Nginx Is the Go‑to Choice for High‑Performance Web and Proxy Services
JD Tech Talk
JD Tech Talk
Jan 22, 2025 · Operations

Preface

This article addresses a high-concurrency inventory problem in a second-hand market's second-hand market system, focusing on solving the system's inventory deduction issue during flash sales using cache and asynchronous processing to achieve horizontal scalability.

Cache OptimizationTransaction Handlinghigh concurrency
0 likes · 10 min read
Preface
JD Cloud Developers
JD Cloud Developers
Jan 22, 2025 · Backend Development

Mastering High-Concurrency Inventory Deduction for Flash Sale Systems

This article explores practical strategies for handling the high‑concurrency inventory deduction problem in flash‑sale scenarios, covering lock‑based approaches, Redis caching, partitioned stock management, asynchronous updates, and distributed scaling techniques to prevent overselling and improve throughput.

Backend ArchitectureDistributed SystemsMySQL
0 likes · 11 min read
Mastering High-Concurrency Inventory Deduction for Flash Sale Systems
Open Source Linux
Open Source Linux
Jan 22, 2025 · Backend Development

Unveiling the Secrets Behind China’s 12306 Railway Ticketing Powerhouse

The article explores the evolution, architecture, and massive scalability of China’s 12306 railway ticketing system, highlighting its real‑time processing, distributed three‑tier design, historical development from Unix to modern CS platforms, and the unique challenges that make it one of the world’s most robust backend systems.

ChinaScalabilitydistributed architecture
0 likes · 9 min read
Unveiling the Secrets Behind China’s 12306 Railway Ticketing Powerhouse
dbaplus Community
dbaplus Community
Jan 14, 2025 · Backend Development

Mastering High‑Performance, High‑Concurrency, High‑Availability Backend Systems

This article shares a backend engineer's practical methodology for building systems that simultaneously achieve high performance, high concurrency, and high availability, covering performance optimization, scaling strategies, fault‑tolerance techniques, and real‑world case studies from B‑ and C‑side logistics platforms.

CachingDDDSystem Design
0 likes · 27 min read
Mastering High‑Performance, High‑Concurrency, High‑Availability Backend Systems
IT Architects Alliance
IT Architects Alliance
Jan 8, 2025 · Backend Development

Mastering High Concurrency in Distributed Systems: Strategies & Real-World Cases

This article explores the challenges of handling massive simultaneous requests in distributed architectures and presents practical solutions such as load balancing, distributed caching, asynchronous processing, and sharding, illustrated with case studies from major e‑commerce and social platforms.

Backend ArchitectureCachingDistributed Systems
0 likes · 20 min read
Mastering High Concurrency in Distributed Systems: Strategies & Real-World Cases
Top Architecture Tech Stack
Top Architecture Tech Stack
Jan 8, 2025 · Operations

Technical Evolution and Architecture of China's 12306 Railway Ticketing System

The article reviews the historical development, distributed architecture, high‑concurrency handling, and operational challenges of China's 12306 railway ticketing platform, highlighting its evolution from early Unix‑based systems to the modern large‑scale, real‑time service that supports hundreds of millions of users during peak travel periods.

ChinaRailwaydistributed architecture
0 likes · 9 min read
Technical Evolution and Architecture of China's 12306 Railway Ticketing System
Java Tech Enthusiast
Java Tech Enthusiast
Jan 3, 2025 · Backend Development

Automated Ticket Ordering Feature in China Railway 12306: Design and Implementation

China Railway’s 12306 trial of an automatic ticket‑ordering feature lets users pre‑select up to 60 trains, set priority and pre‑pay the highest fare for Spring Festival travel, with the system submitting orders automatically, handling refunds, and addressing priority sorting, scheduling, payment accuracy, and server load through extensive stress testing and a gray‑release strategy.

AutomationSystem Designbackend
0 likes · 6 min read
Automated Ticket Ordering Feature in China Railway 12306: Design and Implementation
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 30, 2024 · Backend Development

How to Define and Tackle High Concurrency: Strategies and Code Samples

This article explains what constitutes high concurrency, categorizes load levels, and presents practical solutions such as load balancing, database sharding, query optimization, caching, message queues, and rate‑limiting, complete with code examples for implementing these techniques in backend systems.

Rate Limitingdatabase shardinghigh concurrency
0 likes · 7 min read
How to Define and Tackle High Concurrency: Strategies and Code Samples
Liangxu Linux
Liangxu Linux
Dec 29, 2024 · Backend Development

Master epoll: Boost Linux Server Performance with Event‑Driven I/O

This article explains how epoll works as Linux's high‑performance I/O multiplexer, compares it with select and poll, details its three‑step workflow, data structures, code examples, and the trade‑offs between level‑triggered and edge‑triggered modes for building scalable network servers.

ETEvent-drivenI/O Multiplexing
0 likes · 22 min read
Master epoll: Boost Linux Server Performance with Event‑Driven I/O
Architect
Architect
Dec 29, 2024 · Backend Development

The Architecture and Evolution of China's 12306 Railway Ticketing System

An in‑depth look at the evolution of China’s 12306 railway ticketing platform, tracing its origins from early Unix‑based reservation software through successive upgrades, distributed architectures, massive concurrency handling, and the unique centralized design that makes it one of the world’s most robust high‑traffic web systems.

Chinadistributed architecturehigh concurrency
0 likes · 10 min read
The Architecture and Evolution of China's 12306 Railway Ticketing System
macrozheng
macrozheng
Dec 28, 2024 · Operations

What Makes China’s 12306 Railway Ticketing System So Resilient?

The article examines China’s 12306 railway ticketing platform, tracing its evolution from early Unix‑based reservation software to a massive, real‑time, three‑tier distributed system that handles billions of requests during peak travel periods, highlighting its architectural challenges, high‑concurrency solutions, and unique national centralization.

ChinaDistributed Systemshigh concurrency
0 likes · 9 min read
What Makes China’s 12306 Railway Ticketing System So Resilient?
Architecture Digest
Architecture Digest
Dec 22, 2024 · Backend Development

Technical Overview and History of China’s 12306 Railway Ticketing System

The article provides a detailed, informal yet informative overview of the evolution, architecture, and massive scale challenges of China’s 12306 railway ticketing platform, tracing its roots from early Unix‑based systems to modern distributed backend solutions handling billions of requests during peak travel periods.

Backend ArchitectureChinaDistributed Systems
0 likes · 9 min read
Technical Overview and History of China’s 12306 Railway Ticketing System
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 10, 2024 · Backend Development

Understanding High Concurrency in Nginx: Configuration Tips and Best Practices

This article explains what constitutes high concurrency for Nginx, outlines the hardware and software factors that affect its performance, and provides concrete configuration examples such as worker_processes, worker_connections, and other tuning directives to help achieve stable high‑traffic handling.

Backend PerformanceSystem Optimizationconfiguration tuning
0 likes · 4 min read
Understanding High Concurrency in Nginx: Configuration Tips and Best Practices
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 4, 2024 · Backend Development

How Nginx Achieves Million-Connection Concurrency: Architecture and Optimization Techniques

This article explains how Nginx uses an event‑driven, asynchronous non‑blocking I/O model together with epoll/kqueue and various optimization strategies such as keep‑alive, caching, efficient data structures and load balancing to handle millions of concurrent connections in large‑scale internet architectures.

Event-drivenasynchronous I/Obackend optimization
0 likes · 5 min read
How Nginx Achieves Million-Connection Concurrency: Architecture and Optimization Techniques
Tencent Cloud Developer
Tencent Cloud Developer
Nov 13, 2024 · Backend Development

Design and Implementation of an E‑commerce Coupon System

The article details a high‑concurrency e‑commerce coupon system that separates creation and distribution, uses Redis‑Lua atomic stock deduction with asynchronous replenishment and coupon generation, employs a lightweight distributed‑transaction table, and adds bucket and batch optimizations to safely handle tens of thousands of TPS.

Coupon SystemRedis Luadistributed-transaction
0 likes · 11 min read
Design and Implementation of an E‑commerce Coupon System
Lobster Programming
Lobster Programming
Nov 9, 2024 · Databases

How to Split Hot Keys in Redis Cluster to Avoid Single-Shard Bottlenecks

Redis can become a bottleneck when a hot key concentrates traffic on a single shard; this article explains how to split such hot keys into multiple sub‑keys, distribute them across cluster nodes using CRC16 slot mapping, and implement the approach in high‑concurrency scenarios like coupon grabs or real‑time leaderboards.

ClusterKey ShardingRedis
0 likes · 6 min read
How to Split Hot Keys in Redis Cluster to Avoid Single-Shard Bottlenecks
dbaplus Community
dbaplus Community
Nov 5, 2024 · Backend Development

How a Two‑Level Cache Boosted High‑Concurrency Performance in a Kubernetes System

The article details how designing a two‑level cache architecture—combining local and distributed caches—dramatically reduced CPU usage, response time, and improved system capacity under high QPS workloads in a Kubernetes‑based container environment, while evaluating trade‑offs of several caching strategies.

Backend DevelopmentCachingPerformance Optimization
0 likes · 11 min read
How a Two‑Level Cache Boosted High‑Concurrency Performance in a Kubernetes System
Architect
Architect
Nov 3, 2024 · Backend Development

How Ctrip Scaled Its Ticket Booking System for Flash‑Sale Events

This article analyzes the challenges Ctrip faced when handling massive traffic during ticket flash‑sale events and details the architectural upgrades, caching strategies, database optimizations, supplier integration safeguards, and traffic‑control mechanisms that enabled stable, fast, and consistent booking experiences.

CachingDistributed SystemsSystem architecture
0 likes · 18 min read
How Ctrip Scaled Its Ticket Booking System for Flash‑Sale Events
Architect
Architect
Oct 27, 2024 · Backend Development

How We Scaled a Lottery System to Over 1M Daily Users: Architecture & Performance Hacks

This article details the end‑to‑end architecture and step‑by‑step performance tuning of a high‑traffic lottery platform, covering server‑level rate limiting, application‑level throttling, semaphore usage, user‑behavior detection, caching strategies, database optimizations, and hardware upgrades that together enabled stable handling of millions of daily requests.

Backend ArchitecturePerformance OptimizationRate Limiting
0 likes · 15 min read
How We Scaled a Lottery System to Over 1M Daily Users: Architecture & Performance Hacks
Architect
Architect
Oct 24, 2024 · Backend Development

Design and Implementation of Delivery Promise System in ZuanZuan App

This article explains how ZuanZuan designs and implements a high‑performance delivery‑promise (fulfilment timing) system, covering the definition of delivery promise, the order‑OMS‑WMS‑TMS workflow, estimated‑arrival calculations, high‑QPS handling with caching and Redis, and the logic behind next‑day and same‑day delivery filters.

Order Managementdelivery promisee-commerce
0 likes · 9 min read
Design and Implementation of Delivery Promise System in ZuanZuan App
Alibaba Cloud Native
Alibaba Cloud Native
Oct 20, 2024 · Backend Development

How Adaptive K‑Value Backoff Locks Boost RocketMQ Performance by Up to 38%

A recent CCF‑A conference paper reveals that an adaptive K‑value backoff lock, derived from queueing theory and implemented in Apache RocketMQ, can replace both spin and mutex locks, achieving up to 37.58% performance gains on x86 CPUs and 32.82% on ARM while reducing CPU usage and resource consumption.

Performance tuningRocketMQbackend systems
0 likes · 7 min read
How Adaptive K‑Value Backoff Locks Boost RocketMQ Performance by Up to 38%
Architecture & Thinking
Architecture & Thinking
Oct 10, 2024 · Backend Development

How CAS Solves High-Concurrency Consistency Issues and the Hidden ABA Problem

This article examines typical high‑concurrency scenarios such as payment processing, online ordering, and cross‑bank transfers, introduces the Compare‑and‑Swap (CAS) approach to ensure strong consistency, explains the ABA problem it can cause, and presents application‑level and data‑layer strategies—including versioning and SQL examples—to mitigate it.

ABA problemCASVersioning
0 likes · 9 min read
How CAS Solves High-Concurrency Consistency Issues and the Hidden ABA Problem
Architect
Architect
Oct 1, 2024 · Backend Development

How We Engineered a Million‑User Lottery System to Survive Massive Spikes

This article details the end‑to‑end architecture, rate‑limiting strategies, caching layers, database optimizations, and hardware upgrades that enabled a lottery service to handle daily traffic exceeding one million users during peak promotional events.

Backend ArchitectureCachingPerformance Optimization
0 likes · 15 min read
How We Engineered a Million‑User Lottery System to Survive Massive Spikes
IT Services Circle
IT Services Circle
Sep 27, 2024 · Operations

Analysis of the Shanghai Stock Exchange Outage and System Design Lessons

The article recounts the Shanghai Stock Exchange’s sudden P0 outage that halted trading, analyzes the causes such as massive order volume and system bottlenecks, and discusses how distributed architectures and message‑queue based queuing can mitigate similar high‑concurrency failures.

Distributed SystemsOperationshigh concurrency
0 likes · 6 min read
Analysis of the Shanghai Stock Exchange Outage and System Design Lessons
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 19, 2024 · Backend Development

Understanding High Concurrency: TPS Thresholds and Architectural Solutions

The article explains what high concurrency means, defines TPS thresholds for moderate, high, and ultra‑high traffic, and outlines key backend techniques such as distributed and microservice architectures, caching, load balancing, traffic shaping, and rate‑limiting/circuit‑breaking to handle massive request volumes.

CachingRate LimitingTPS
0 likes · 6 min read
Understanding High Concurrency: TPS Thresholds and Architectural Solutions
Big Data Technology & Architecture
Big Data Technology & Architecture
Sep 18, 2024 · Databases

Doris Performance Optimization: OLAP Query, Indexes, Vectorized Execution, and High‑Concurrency Point Queries

This article explains how Apache Doris achieves high‑concurrency OLAP and point‑query performance through MPP architecture, columnar storage, partition‑bucket pruning, various indexes, materialized views, vectorized execution, runtime filters, short‑circuit planning, and prepared‑statement caching.

IndexesOLAPdoris
0 likes · 12 min read
Doris Performance Optimization: OLAP Query, Indexes, Vectorized Execution, and High‑Concurrency Point Queries
JD Cloud Developers
JD Cloud Developers
Sep 4, 2024 · Backend Development

Mastering High‑Performance, High‑Concurrency Backend Systems: Methodologies & Practices

This article explores the evolution of software complexity and presents a comprehensive backend development methodology for building high‑performance, high‑concurrency, and highly available systems, covering performance optimization, read/write strategies, scaling techniques, fault isolation, and deployment practices with real‑world examples.

AvailabilitySystem Designbackend
0 likes · 25 min read
Mastering High‑Performance, High‑Concurrency Backend Systems: Methodologies & Practices
JD Tech Talk
JD Tech Talk
Sep 4, 2024 · Backend Development

Methodology and Practices for Building High‑Performance, High‑Concurrency, High‑Availability Backend Systems

This article shares a backend‑centric methodology and practical experiences for constructing systems that simultaneously achieve high performance, high concurrency, and high availability, covering performance optimization, read/write strategies, scaling techniques, fault‑tolerance mechanisms, and deployment considerations.

System Designbackendhigh availability
0 likes · 24 min read
Methodology and Practices for Building High‑Performance, High‑Concurrency, High‑Availability Backend Systems
JD Tech
JD Tech
Sep 3, 2024 · Backend Development

Designing High‑Performance, High‑Concurrency, High‑Availability Backend Systems: Methodologies and Practices

This article shares a backend engineer’s comprehensive methodology and practical experiences for building systems that simultaneously achieve high performance, high concurrency, and high availability, covering performance optimization, caching strategies, scaling techniques, fault tolerance, and operational best practices across application, storage, and deployment layers.

ScalabilitySystem Designhigh availability
0 likes · 28 min read
Designing High‑Performance, High‑Concurrency, High‑Availability Backend Systems: Methodologies and Practices
System Architect Go
System Architect Go
Aug 15, 2024 · Backend Development

Analyzing the Feasibility of Supporting One Million Concurrent Requests in a Typical System Architecture

This article presents a typical multi‑layer system architecture, examines the theoretical performance limits of each component—including load balancers, HTTP servers, Redis, message queues, relational databases and network bandwidth—and evaluates whether the combined stack can sustain one million concurrent requests.

Database Performancebackendhigh concurrency
0 likes · 6 min read
Analyzing the Feasibility of Supporting One Million Concurrent Requests in a Typical System Architecture
JD Tech Talk
JD Tech Talk
Aug 12, 2024 · Backend Development

Designing High‑Concurrency Systems: From Single‑Machine Optimizations to Distributed Architecture

This article explains how to build high‑concurrency systems by analyzing single‑machine hardware and code optimizations, clarifying multithreading versus asynchronous methods, and then scaling horizontally and vertically with caching, partitioning, and distributed inventory management to achieve stable, performant services for large‑scale e‑commerce workloads.

Backend ArchitectureRedisasynchronous programming
0 likes · 18 min read
Designing High‑Concurrency Systems: From Single‑Machine Optimizations to Distributed Architecture
JD Cloud Developers
JD Cloud Developers
Aug 12, 2024 · Backend Development

Mastering High‑Concurrency: From Thread Pitfalls to Distributed Inventory Architecture

This article explores the three‑high requirements of modern internet systems, compares multithreading with asynchronous methods, and presents a practical, partition‑based inventory‑deduction architecture that leverages Redis caching, MySQL sharding, and asynchronous updates to achieve scalable high‑concurrency performance.

Distributed SystemsMySQLRedis
0 likes · 19 min read
Mastering High‑Concurrency: From Thread Pitfalls to Distributed Inventory Architecture
JD Tech
JD Tech
Aug 9, 2024 · Backend Development

Designing High‑Concurrency Systems: From Single‑Machine Optimizations to Distributed Architecture

This article explains how to build high‑concurrency systems by analyzing hardware and code optimizations on a single machine, exploring multi‑machine scaling, database and business‑application considerations, and presenting a practical inventory‑stock case that evolves from simple locking to partitioned, asynchronous, Redis‑based designs.

CachingSystem architecturedatabase scaling
0 likes · 18 min read
Designing High‑Concurrency Systems: From Single‑Machine Optimizations to Distributed Architecture
DevOps
DevOps
Jul 23, 2024 · Backend Development

High Concurrency Solutions: CDN, Read‑Write Separation, NoSQL, and Caching Strategies

This article explains the concept of high concurrency, its key metrics, and presents four practical backend solutions—static/dynamic separation with CDN, read‑write separation using NoSQL and CQRS, various caching techniques, and lightweight read‑optimisation—to improve performance and scalability of distributed systems.

Backend ArchitectureCDNNoSQL
0 likes · 23 min read
High Concurrency Solutions: CDN, Read‑Write Separation, NoSQL, and Caching Strategies
Ctrip Technology
Ctrip Technology
Jul 5, 2024 · Backend Development

Design and Optimization of Ctrip Ticket Booking Transaction System for Flash‑Sale Events

This article examines the challenges faced by Ctrip’s ticket reservation transaction system during flash‑sale events and details the architectural optimizations—including Redis caching, database load reduction, supplier integration, and multi‑layer traffic throttling—that ensure system stability, strong consistency, and high availability under extreme concurrency.

Data ConsistencySystem architecturehigh availability
0 likes · 16 min read
Design and Optimization of Ctrip Ticket Booking Transaction System for Flash‑Sale Events
Wukong Talks Architecture
Wukong Talks Architecture
Jun 19, 2024 · Backend Development

Design and Optimization of a High‑Concurrency Lottery System

This article details how a large‑scale lottery service was architected and tuned for extreme traffic spikes by applying server‑side rate limiting, application‑level throttling, behavior‑based filtering, caching strategies, database optimizations, and hardware upgrades, resulting in a ten‑fold performance improvement.

Backend ArchitectureDatabase TuningRate Limiting
0 likes · 12 min read
Design and Optimization of a High‑Concurrency Lottery System
DaTaobao Tech
DaTaobao Tech
Jun 17, 2024 · Backend Development

Cache Consistency Issues and Solutions in a High‑Concurrency Push System

The article examines a cache‑consistency failure in Tmall International’s high‑concurrency push system, explains classic cache problems and mitigation techniques, analyzes the delete‑then‑update bug that caused null‑plan errors, and evaluates four corrective strategies ranging from double‑write to delayed double‑delete.

CacheConsistencyData Consistency
0 likes · 13 min read
Cache Consistency Issues and Solutions in a High‑Concurrency Push System
JD Tech
JD Tech
May 29, 2024 · Backend Development

Handling High‑Concurrency Scenarios: Architecture, Caching, Rate Limiting, and Isolation Strategies

This article analyzes the challenges of high‑concurrency environments and presents a comprehensive solution that includes rights verification and issuance processes, cost‑service trade‑offs, three‑high guarantees, rate‑limiting methods, multi‑level caching, request merging, inventory splitting, and isolation techniques to ensure system stability and scalability.

Backend EngineeringCachingSystem architecture
0 likes · 12 min read
Handling High‑Concurrency Scenarios: Architecture, Caching, Rate Limiting, and Isolation Strategies
Alibaba Cloud Developer
Alibaba Cloud Developer
May 24, 2024 · Backend Development

Scalable Architecture for Community & E‑Commerce: Sharding, Caching & Distributed Transactions

This article outlines a comprehensive backend architecture for community platforms and billion‑level e‑commerce systems, covering microservice decomposition, DDD modeling, caching strategies, Redis clustering, message‑queue decoupling, database sharding, read‑write separation, distributed transaction approaches, multithreaded data migration, and massive counting techniques.

CachingShardingSystem architecture
0 likes · 14 min read
Scalable Architecture for Community & E‑Commerce: Sharding, Caching & Distributed Transactions
Wukong Talks Architecture
Wukong Talks Architecture
May 23, 2024 · Backend Development

Key Design Principles for High‑Concurrency Architecture and Read/Write Separation

This article explains the essential conditions, metrics, and scenario classifications for building high‑concurrency systems, then details common solutions such as database read/write separation, local and distributed caching, cache‑eviction policies, handling master‑slave lag, preventing cache penetration and avalanche, and applying CQRS to achieve scalable, high‑performance back‑end services.

CQRSCachingDatabase
0 likes · 21 min read
Key Design Principles for High‑Concurrency Architecture and Read/Write Separation
Programmer DD
Programmer DD
May 23, 2024 · Backend Development

Mastering High‑Concurrency Architecture: From Metrics to Read/Write Splitting and Caching

This article explains the essential elements of high‑concurrency system design—performance, availability, scalability—introduces quantitative metrics, classifies read‑heavy and write‑heavy scenarios, and details practical solutions such as database read/write separation, local and distributed caching, cache‑penetration and avalanche mitigation, and CQRS implementation for billion‑user applications.

CQRSCachingRedis
0 likes · 22 min read
Mastering High‑Concurrency Architecture: From Metrics to Read/Write Splitting and Caching
Lobster Programming
Lobster Programming
May 9, 2024 · Backend Development

Detect Hot Items in High‑Concurrency Sales Using OpenResty, Kafka & Elasticsearch

During flash‑sale events like JD or Taobao, a tiny fraction of products generate the majority of traffic, causing server overload; this guide explains how to identify and collect hotspot product data in real time using an OpenResty‑Lua front‑end, Kafka for messaging, and Elasticsearch for storage and analysis.

ElasticsearchHot ItemsKafka
0 likes · 5 min read
Detect Hot Items in High‑Concurrency Sales Using OpenResty, Kafka & Elasticsearch
JD Tech
JD Tech
May 8, 2024 · Backend Development

High‑Concurrency Techniques for the Baige Traffic Operations Platform

This article outlines a comprehensive set of high‑concurrency strategies—including caching, rate limiting, circuit breaking, asynchronous processing, pooling, code optimization, JVM tuning, horizontal scaling, warm‑up, data heterogeneity, and sharding—applied to the Baige traffic platform to handle tens of thousands of QPS during peak loads.

CachingCircuit Breakinghigh concurrency
0 likes · 8 min read
High‑Concurrency Techniques for the Baige Traffic Operations Platform
Lobster Programming
Lobster Programming
May 6, 2024 · Backend Development

Scaling Homepage Carousel to Millions of QPS with OpenResty, Lua, Redis, and MQ

This article explains how to design a high‑QPS hotspot data caching and retrieval system for e‑commerce homepages using OpenResty, Lua, Redis, and a message queue, detailing publishing, reading processes, workflow diagrams, and a complete Lua script that can sustain tens of thousands to millions of concurrent requests.

LuaOpenRestyRedis
0 likes · 6 min read
Scaling Homepage Carousel to Millions of QPS with OpenResty, Lua, Redis, and MQ
dbaplus Community
dbaplus Community
Apr 17, 2024 · Backend Development

How We Scaled a Volunteer Registration System to 20k QPS with Redis, RocketMQ, and MySQL

This article recounts how a volunteer registration platform was redesigned to meet extreme concurrency demands—handling up to 40k QPS and 20k TPS—by evaluating MySQL limits, adding Redis caching, integrating RocketMQ, applying fault‑recovery mechanisms, and iteratively optimizing through multiple load‑testing rounds.

MySQLRedisRocketMQ
0 likes · 16 min read
How We Scaled a Volunteer Registration System to 20k QPS with Redis, RocketMQ, and MySQL
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Apr 17, 2024 · Backend Development

Mastering High Concurrency: Boost Your Backend Performance

This article explains what high concurrency is, why it matters for large‑scale systems, and presents practical techniques such as distributed caching, load balancing, database optimization, traffic shaping, and distributed architecture to dramatically improve a backend's ability to handle massive simultaneous requests.

Backend PerformanceDatabase OptimizationDistributed Cache
0 likes · 9 min read
Mastering High Concurrency: Boost Your Backend Performance
Liangxu Linux
Liangxu Linux
Apr 15, 2024 · Backend Development

How Nginx Handles Millions of Concurrent Connections: Architecture Explained

This article explains why Nginx is renowned for high performance and details the architectural components—master and worker processes, event‑driven non‑blocking I/O, memory pooling, load‑balancing, caching, modular design, and proxy mechanisms—that enable it to sustain millions of simultaneous connections.

CachingEvent-drivenSystem architecture
0 likes · 12 min read
How Nginx Handles Millions of Concurrent Connections: Architecture Explained
Sohu Tech Products
Sohu Tech Products
Apr 10, 2024 · Databases

ShardingSphere-JDBC Database Sharding Tutorial Project

The tutorial project showcases how to implement database sharding with ShardingSphere-JDBC (versions 4 and 5) in a SpringBoot O2O order service, providing modules for sharding, a gRPC ID generator, detailed configuration of four data sources, sharding algorithms, and Swagger-based testing of order creation and queries.

ShardingSphere-JDBCSpringBootdatabase scaling
0 likes · 5 min read
ShardingSphere-JDBC Database Sharding Tutorial Project
Yum! Tech Team
Yum! Tech Team
Apr 9, 2024 · Backend Development

Optimizing High‑Concurrency Menu Services with Go sync.Pool Object Pool

This article explains the principles of object pools, details the internal implementation of Go's sync.Pool, and demonstrates through benchmarks how using an object pool can dramatically reduce memory allocation and latency for high‑traffic menu services in a restaurant ordering application.

BenchmarkGohigh concurrency
0 likes · 13 min read
Optimizing High‑Concurrency Menu Services with Go sync.Pool Object Pool
Architect
Architect
Apr 3, 2024 · Databases

Database and Cache Double-Write Consistency: Common Solutions and Best Practices

This article examines the data consistency challenges of writing to both databases and caches, outlines four common double‑write strategies, analyzes their pitfalls—especially under high concurrency—and recommends the optimal approach of writing to the database then deleting the cache, while discussing retry mechanisms, scheduled tasks, message queues, and binlog listeners.

Cachedatabase-consistencyhigh concurrency
0 likes · 15 min read
Database and Cache Double-Write Consistency: Common Solutions and Best Practices