BestHub
Sign in
Tagged articles

high-concurrency

865 articles · Page 1 of 9
Ray's Galactic Tech
Ray's Galactic Tech
Aug 20, 2026 · Backend Development

Why Wallet Balance Shouldn't Be Calculated On‑The‑Fly: Double‑Entry Accounting, Snapshots, and Immutable Ledger Practices

The article explains that a production‑grade wallet must store balance snapshots instead of summing transaction flows, using double‑entry bookkeeping, ACID guarantees, idempotent request handling, outbox messaging, sharding, and comprehensive reconciliation to ensure correctness and high‑throughput under heavy concurrency.

balance snapshotdouble-entry accountinghigh-concurrency
0 likes · 43 min read
Why Wallet Balance Shouldn't Be Calculated On‑The‑Fly: Double‑Entry Accounting, Snapshots, and Immutable Ledger Practices
Mike Chen Rui
Mike Chen Rui
Aug 19, 2026 · Backend Development

What TPS Levels Define a High‑Performance E‑Commerce Flash Sale?

The article explains how flash‑sale systems differ from regular e‑commerce, outlines characteristic traffic spikes, and defines TPS ranges—100‑1,000, 1,000‑5,000, 5,000‑10,000, and 10,000‑50,000—that indicate low, medium, mature, and ultra‑high concurrency, while noting the architectural techniques needed to sustain tens of thousands of requests.

E‑commerceMessage QueueRedis
0 likes · 4 min read
What TPS Levels Define a High‑Performance E‑Commerce Flash Sale?
Architecture Digest
Architecture Digest
Aug 18, 2026 · Backend Development

How to Design a ThreadPool to Send 10 Million SMS in One Hour – Interview Insights

Sending 10 million marketing SMS within an hour forces careful thread‑pool design: avoid unbounded queues that cause OOM, choose a bounded ThreadPoolExecutor, dynamically tune core/max sizes, use CallerRunsPolicy for natural back‑pressure, and add persistence and compensation mechanisms to guarantee reliability.

Java concurrencyOOM preventionThreadPoolExecutor
0 likes · 8 min read
How to Design a ThreadPool to Send 10 Million SMS in One Hour – Interview Insights
Java Architect Handbook
Java Architect Handbook
Aug 17, 2026 · Backend Development

Interview Question: What Is Flash‑Sale Warmup and Why Does It Matter?

The article explains warmup (prewarm) as the practice of moving a Java system from a cold to a hot state before traffic arrives, covering JVM JIT compilation, cache preloading, connection‑pool and thread‑pool initialization, service gray‑release, and how these steps prevent cold‑start failures in high‑concurrency scenarios.

CacheJVMconnection-pool
0 likes · 13 min read
Interview Question: What Is Flash‑Sale Warmup and Why Does It Matter?
Cloud Architecture
Cloud Architecture
Aug 16, 2026 · Backend Development

How to Build a 100k QPS Seckill System with Spring Boot, Redis, and Lua

This article provides a production‑grade, step‑by‑step engineering guide for designing a high‑concurrency seckill (flash‑sale) system that can sustain 100,000 QPS using Spring Boot, Redis with Lua scripts, asynchronous messaging, and comprehensive fault‑tolerance, monitoring, and scalability techniques.

LuaRedisSeckill
0 likes · 40 min read
How to Build a 100k QPS Seckill System with Spring Boot, Redis, and Lua
MaGe Linux Operations
MaGe Linux Operations
Aug 16, 2026 · Operations

Tuning Nginx Worker Processes and Connections for High‑Concurrency Scenarios

This guide walks through the complete workflow for analyzing, configuring, and validating Nginx in high‑traffic environments, covering architecture basics, core parameters, system limits, practical configuration examples, stress‑testing methods, monitoring, risk mitigation, rollback procedures, and production‑grade best practices.

high-concurrencyload balancingnginx
0 likes · 23 min read
Tuning Nginx Worker Processes and Connections for High‑Concurrency Scenarios
Code Farming
Code Farming
Aug 14, 2026 · Backend Development

How Weibo Handles 100k QPS During Viral Peaks: Architectural Secrets

The article breaks down how Weibo’s backend was engineered to sustain 100,000 queries per second during traffic surges by first quantifying load, then using a push‑pull hybrid feed, a four‑tier cache funnel, and user‑ID sharding with write throttling.

backend designcachingfeed architecture
0 likes · 8 min read
How Weibo Handles 100k QPS During Viral Peaks: Architectural Secrets
Java Tech Workshop
Java Tech Workshop
Aug 11, 2026 · Backend Development

Achieving 6 Million Orders per Second with SpringBoot and LMAX Disruptor

The article explains why traditional Java BlockingQueue struggles under high load, introduces the LMAX Disruptor’s lock‑free ring buffer design, compares performance showing up to 600 万+ events per second versus 100 万 for ArrayBlockingQueue, and provides step‑by‑step SpringBoot integration with code examples and best‑practice tips.

DisruptorJavaSpringBoot
0 likes · 17 min read
Achieving 6 Million Orders per Second with SpringBoot and LMAX Disruptor
Code Farming
Code Farming
Aug 9, 2026 · Backend Development

How a System Handles 30 Million Simultaneous Video Views

The article breaks down how QuickTok supports 30 million concurrent video streams by calculating QPS, storage and bandwidth needs, then applying HDFS with HBase indexing and aggressive CDN pre‑warming to shrink traffic from 88 Tbps to under 4 Tbps.

CDNHDFSSystem Design
0 likes · 5 min read
How a System Handles 30 Million Simultaneous Video Views
Java Tech Enthusiast
Java Tech Enthusiast
Aug 9, 2026 · Backend Development

Spring Boot + Disruptor: Achieving Ultra‑Fast High‑Concurrency Processing for 6 Million Orders per Second

This article explains how to replace traditional message queues with LMAX Disruptor in a Spring Boot application, covering its core concepts, step‑by‑step implementation, and a demo that demonstrates lock‑free, high‑throughput processing capable of handling six million orders per second.

DisruptorJavaMessage Queue
0 likes · 10 min read
Spring Boot + Disruptor: Achieving Ultra‑Fast High‑Concurrency Processing for 6 Million Orders per Second
Ray's Galactic Tech
Ray's Galactic Tech
Aug 6, 2026 · Databases

Taming Message Storms: Redis 7.x Engineering Practices for Enterprise Live‑Streaming Platforms

This article dissects why a simple Redis upgrade is insufficient for large‑scale live streaming, then walks through how Redis 7’s Sharded Pub/Sub, Function, and ACL v2 features together eliminate broadcast storms, streamline script governance, and enforce fine‑grained multi‑tenant control, backed by concrete architecture diagrams, production‑grade Java code, capacity planning, monitoring, rollout procedures, and real‑world benchmark results.

ACLRedisRedis Function
0 likes · 41 min read
Taming Message Storms: Redis 7.x Engineering Practices for Enterprise Live‑Streaming Platforms
Mike Chen Rui
Mike Chen Rui
Aug 6, 2026 · Operations

Hands‑on Nginx High‑Concurrency Tuning: Boost Performance Up to 10×

This article walks through practical Nginx high‑concurrency tuning steps—including worker_processes, worker_connections, Linux file‑descriptor limits, and sendfile zero‑copy settings—to dramatically increase throughput and handle tens of thousands of simultaneous connections.

Performance Tuninghigh-concurrencylinux limits
0 likes · 3 min read
Hands‑on Nginx High‑Concurrency Tuning: Boost Performance Up to 10×
Code Farming
Code Farming
Aug 5, 2026 · Backend Development

How to Generate Billions of Conflict‑Free Short URLs

The article breaks down a real‑world architecture for a short‑URL service that must handle 12 billion entries and 40 k QPS, showing how to calculate capacity, compare generation algorithms, use Bloom filters for offline de‑duplication, and employ a three‑layer cache‑plus‑storage design to meet performance goals.

Bloom filterHBaseRedis
0 likes · 7 min read
How to Generate Billions of Conflict‑Free Short URLs
Mike Chen Rui
Mike Chen Rui
Aug 5, 2026 · Backend Development

How Can a Gateway Sustain Million‑Level Concurrency in High‑Traffic Scenarios?

The article explains why a gateway is the first traffic entry in microservice systems and how Spring Cloud Gateway achieves million‑level concurrent handling through a reactive model, non‑blocking I/O, event‑driven scheduling, zero‑copy transmission, and built‑in rate‑limiting mechanisms.

event-drivenhigh-concurrencynon-blocking-io
0 likes · 3 min read
How Can a Gateway Sustain Million‑Level Concurrency in High‑Traffic Scenarios?
Code Farming
Code Farming
Aug 4, 2026 · Backend Development

Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It

When an education company faced 50,000 concurrent re‑registration requests, its monolithic internal‑external architecture collapsed, but by physically separating networks, enforcing gateway rate‑limiting and circuit‑breaking, pre‑loading data into Redis, and using one‑way Kafka streams, the system remained stable.

KafkaRedisbackend architecture
0 likes · 6 min read
Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It
Ray's Galactic Tech
Ray's Galactic Tech
Aug 4, 2026 · Backend Development

Spring Boot & Netty MQTT Platform: Multi‑Protocol and Modular Design

This guide walks through building a high‑performance, scalable MQTT access gateway for IoT using Spring Boot for service orchestration and Netty for connection handling, covering protocol fundamentals, modular architecture, multi‑protocol adaptation, session management, high‑concurrency optimizations, clustering, observability, and deployment best practices.

IoTKubernetesMQTT
0 likes · 40 min read
Spring Boot & Netty MQTT Platform: Multi‑Protocol and Modular Design
Code Farming
Code Farming
Jul 30, 2026 · Backend Development

Can Your System Survive a Sudden 500K Live Viewers? 4 Proven Traffic‑Splitting Techniques

When a live broadcast suddenly attracts 500,000 viewers, the system faces 100,000 QPS likes and rapid reward transactions; this article breaks down a battle‑tested traffic‑splitting architecture—room‑based sharding, queue buffering, multi‑layer write caching, and consistent‑hash sharding—showing how each component controls load, ensures consistency, and enables seamless scaling.

System Designconsistent hashingdistributed cache
0 likes · 6 min read
Can Your System Survive a Sudden 500K Live Viewers? 4 Proven Traffic‑Splitting Techniques
Mike Chen Rui
Mike Chen Rui
Jul 27, 2026 · Backend Development

What Defines High‑Concurrency for Nginx? A Clear Guide

The article explains that “high concurrency” for Nginx is relative, depends on hardware, request type, response size, and overall architecture, and provides typical connection and QPS ranges for ordinary, medium, high‑traffic, and ultra‑high‑traffic systems.

QPSconnection limitshigh-concurrency
0 likes · 2 min read
What Defines High‑Concurrency for Nginx? A Clear Guide
Cloud Architecture
Cloud Architecture
Jul 26, 2026 · Backend Development

Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales

This article presents a comprehensive, step‑by‑step analysis of building a flash‑sale (seckill) system that can survive instant traffic spikes, detailing seven essential design ideas such as static page delivery, token gating, Redis atomic decrement, asynchronous queuing, multi‑layer rate limiting, service isolation, idempotent processing, and end‑to‑end monitoring and recovery.

LuaMQRedis
0 likes · 28 min read
Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales
Architect's Guide
Architect's Guide
Jul 25, 2026 · Backend Development

The Art of Building a High‑Concurrency Flash‑Sale System

This article dissects the architecture of a massive flash‑sale service like 12306, covering multi‑layer load balancing, Nginx weighted round‑robin, stock‑deduction strategies, a Go‑based implementation with Redis and Lua, and performance results that demonstrate handling millions of concurrent ticket requests.

GoRedisflash sale
0 likes · 22 min read
The Art of Building a High‑Concurrency Flash‑Sale System
samdeepthink
samdeepthink
Jul 23, 2026 · Backend Development

Enterprise-Scale Source Code for 4 Real-World Projects: Flash Sale, Product Catalog, Payment System, and DDD Implementation

The author releases the complete, production‑ready source code for four enterprise‑level projects—a flash‑sale service handling 60 million members, a high‑concurrency product system for hundreds of millions of users, a payment platform serving over a hundred million users, and a three‑year DDD migration case study—while the fifth column remains under development.

DDDJavaPayment Integration
0 likes · 5 min read
Enterprise-Scale Source Code for 4 Real-World Projects: Flash Sale, Product Catalog, Payment System, and DDD Implementation
Code Farming
Code Farming
Jul 20, 2026 · Backend Development

How a Message Queue Keeps Flash‑Sale Systems Stable Under 10k Orders per Second

The article explains how using a message queue as a buffer, asynchronous processor, and decoupling layer enables flash‑sale systems to handle tens of thousands of orders per second, reducing database overload, cutting response time from 500 ms to 50 ms, and preventing cascade failures.

DecouplingMessage QueueSystem Design
0 likes · 5 min read
How a Message Queue Keeps Flash‑Sale Systems Stable Under 10k Orders per Second
Ray's Galactic Tech
Ray's Galactic Tech
Jul 17, 2026 · Artificial Intelligence

High‑Concurrency RAG: When to Use Classic, Graph or Agentic Architecture

The article analyzes why production‑grade RAG systems fail under load and explains how Classic, Graph, and Agentic RAG each address specific problem stages, offering concrete engineering guidelines for query normalization, caching, versioned knowledge, graph construction, stateful agents, and governance to achieve stable high‑throughput performance.

Agentic RAGRAGRetrieval Augmented Generation
0 likes · 31 min read
High‑Concurrency RAG: When to Use Classic, Graph or Agentic Architecture
Ray's Galactic Tech
Ray's Galactic Tech
Jul 16, 2026 · Backend Development

Building a Scalable Smart Tag System for 100k QPS with AI‑Generated Code

The article explains that while many teams focus on model accuracy, the real challenges of an AI‑powered tagging system are write spikes, timeouts, duplicate tagging, cost overruns and state inconsistency, and it proposes a five‑layer architecture, async fallback, governance and validation practices to reliably achieve a 100 k QPS target.

AI taggingKafkaLLM Integration
0 likes · 30 min read
Building a Scalable Smart Tag System for 100k QPS with AI‑Generated Code
Java Tech Workshop
Java Tech Workshop
Jul 15, 2026 · Backend Development

Generating Trillions of Unique Order IDs Without Collisions

The article analyzes why simple auto‑increment or timestamp‑based IDs fail at massive scales, compares common distributed ID schemes, and presents an improved Snowflake‑plus‑segment hybrid solution with clock‑rollback protection, automatic machine/room allocation, and production‑grade safeguards for trillion‑level order processing.

JavaMySQLdistributed ID
0 likes · 19 min read
Generating Trillions of Unique Order IDs Without Collisions
Ray's Galactic Tech
Ray's Galactic Tech
Jul 14, 2026 · Cloud Native

Spring Boot + Netty MQTT Gateway for Million Connections & Millisecond Push

To support millions of persistent MQTT connections with sub‑millisecond latency, the article walks through a Spring Boot + Netty cloud‑native gateway design that separates connection, event, state and governance planes, details async authentication, back‑pressure handling, command state machines, and loss‑less Kubernetes roll‑outs.

KafkaKubernetesMQTT
0 likes · 38 min read
Spring Boot + Netty MQTT Gateway for Million Connections & Millisecond Push
Code Farming
Code Farming
Jul 13, 2026 · Backend Development

Mastering Traffic Control: Keeping Systems Stable Under a Million Concurrent Requests

The article explains how to prevent system crashes during massive traffic spikes by applying three core techniques—rate limiting, circuit breaking, and graceful degradation—detailing algorithm choices, state machines, and practical implementation steps for high‑concurrency back‑end services.

System Designbackendcircuit breaker
0 likes · 6 min read
Mastering Traffic Control: Keeping Systems Stable Under a Million Concurrent Requests
Cloud Architecture
Cloud Architecture
Jul 13, 2026 · Backend Development

Production-Grade Payment System Guide: Java Implementation for Alipay & WeChat All-Channel Integration

This article explains why a payment system is more than a simple SDK integration, presents a four‑layer architecture (access, state, event, governance), details state machines, idempotent callbacks, outbox pattern, reconciliation, high‑concurrency handling, observability, security, and provides Java code examples for integrating Alipay and WeChat across all channels.

AlipayJavaOutbox
0 likes · 29 min read
Production-Grade Payment System Guide: Java Implementation for Alipay & WeChat All-Channel Integration
Architect Chen
Architect Chen
Jul 13, 2026 · Databases

How I/O Multiplexing Gives Redis a 10× Performance Boost

Redis achieves its high speed not only because it is an in‑memory, single‑threaded database with efficient data structures, but primarily thanks to I/O multiplexing, which lets a single thread manage tens of thousands of client connections, dramatically cutting thread‑switch overhead and boosting throughput up to tenfold.

I/O multiplexingRedisepoll
0 likes · 4 min read
How I/O Multiplexing Gives Redis a 10× Performance Boost
Code Farming
Code Farming
Jul 13, 2026 · Backend Development

Designing Trillion‑Scale Counters: From MySQL to a Custom Redis Engine

The article dissects a proven trillion‑level counter architecture, tracing its evolution from a simple MySQL table through hash sharding, a full Redis migration, deep Redis memory optimizations, and hot‑cold separation, while detailing the trade‑offs and performance gains at each step.

Message QueueRedis optimizationcounter architecture
0 likes · 6 min read
Designing Trillion‑Scale Counters: From MySQL to a Custom Redis Engine
YiSu Grain
YiSu Grain
Jul 9, 2026 · Backend Development

Mapping Database & Architecture Patterns onto an E‑Commerce High‑Concurrency Diagram

This article reviews weeks 8‑13 of a system‑architecture course—covering indexes, ACID, MVCC, high availability, performance tuning, and case‑study templates—and shows how to combine those concepts into a complete e‑commerce high‑concurrency solution with caching, load‑balancing, async processing, database optimization, HA clustering, and concurrency control.

E‑commercecachingdatabase optimization
0 likes · 18 min read
Mapping Database & Architecture Patterns onto an E‑Commerce High‑Concurrency Diagram
Cloud Architecture
Cloud Architecture
Jul 9, 2026 · Backend Development

How Spring Boot, Kafka, Redis, and MongoDB Power Real‑Time GPS Tracking for Millions of Vehicles

This article walks through a production‑grade architecture that uses Spring Boot, Kafka, Redis, and MongoDB to ingest, buffer, order, and store high‑frequency vehicle GPS data from hundreds of thousands of devices while guaranteeing low latency, scalability, fault‑tolerance, and accurate replay capabilities.

KafkaMongoDBRedis
0 likes · 38 min read
How Spring Boot, Kafka, Redis, and MongoDB Power Real‑Time GPS Tracking for Millions of Vehicles
Cloud Architecture
Cloud Architecture
Jul 8, 2026 · Backend Development

High‑Concurrency Order System Architecture: How Redis, MySQL, and Elasticsearch Collaborate Without Overstepping

This article presents a production‑grade, high‑concurrency order system design that separates responsibilities among Redis for traffic control, MySQL as the single source of truth, Kafka for event propagation, and Elasticsearch for search, while detailing state‑machine modeling, outbox patterns, seckill flow, and comprehensive observability and deployment practices.

ElasticsearchMySQLOutbox
0 likes · 31 min read
High‑Concurrency Order System Architecture: How Redis, MySQL, and Elasticsearch Collaborate Without Overstepping
Cloud Architecture
Cloud Architecture
Jul 7, 2026 · Backend Development

From HTTP Polling to MQTT Push: Evolving High‑Concurrency IoT Device Access Architecture

Switching from HTTP polling to MQTT for massive IoT deployments requires rethinking connection models, topic design, state management, and engineering practices, as the article details the architectural evolution, four‑plane production design, code patterns, and operational safeguards needed for reliable high‑concurrency device access.

Device AccessEvent StreamingIoT
0 likes · 46 min read
From HTTP Polling to MQTT Push: Evolving High‑Concurrency IoT Device Access Architecture
Code Farming
Code Farming
Jul 7, 2026 · Backend Development

Four Ways to Ensure Unique IDs After Database Sharding

When a system is split into multiple databases and tables, the article explains the root cause of ID collisions and compares four mainstream ID generation strategies—UUID, database auto‑increment, Snowflake, and segment allocation—detailing their trade‑offs, pitfalls, and selection guidelines for different concurrency levels.

distributed IDhigh-concurrencysegment allocation
0 likes · 9 min read
Four Ways to Ensure Unique IDs After Database Sharding
IT Learning Made Simple
IT Learning Made Simple
Jul 6, 2026 · Backend Development

How Chaotic Architecture Can Sink an E‑commerce Business – Lessons from the Drama “E‑commerce Storm”

The article uses the drama “E‑commerce Storm” to illustrate how failures in the four‑layer e‑commerce architecture—front‑end, business logic, data persistence, and server/operations—lead to order chaos, permission breaches, database crashes, and DDoS attacks, and shows how refactoring and security hardening can prevent collapse.

Cloud OperationsE‑commerceRBAC
0 likes · 6 min read
How Chaotic Architecture Can Sink an E‑commerce Business – Lessons from the Drama “E‑commerce Storm”
Subtle Storm
Subtle Storm
Jul 1, 2026 · Backend Development

How to Tackle the “Three Highs” of Internet Systems Without Burning Out

The article analyzes the intertwined challenges of high concurrency, high performance, and high availability in internet services, explains why they cannot all be maximized simultaneously, and presents concrete architectural tactics—partitioning, caching, async processing, redundancy, and CAP trade‑offs—to achieve a balanced, resilient system.

CAP theoremcachingdistributed systems
0 likes · 7 min read
How to Tackle the “Three Highs” of Internet Systems Without Burning Out
Cloud Architecture
Cloud Architecture
Jun 29, 2026 · Databases

Deep Guide to MySQL Index Failure: From Core Mechanics to High‑Concurrency Production Practices

This comprehensive guide explains why seemingly indexed MySQL queries can still cause severe latency spikes in high‑traffic systems, explores the underlying InnoDB structures and optimizer cost model, enumerates twelve common failure patterns with concrete SQL examples, and provides a production‑grade methodology for diagnosing, engineering, and automating index governance.

InnoDBMySQLPerformance Tuning
0 likes · 39 min read
Deep Guide to MySQL Index Failure: From Core Mechanics to High‑Concurrency Production Practices
Cloud Architecture
Cloud Architecture
Jun 27, 2026 · Backend Development

Enterprise Messaging System Deep Dive: Core Engine to High‑Concurrency

This guide explains how enterprise messaging systems reliably propagate state changes across distributed services, covering core concepts, outbox patterns, topic/tag modeling, consumer idempotency, dead‑letter handling, high‑concurrency engineering, monitoring, and Kubernetes deployment to build a production‑grade, observable platform.

KafkaObservabilityOutbox
0 likes · 44 min read
Enterprise Messaging System Deep Dive: Core Engine to High‑Concurrency
Cloud Architecture
Cloud Architecture
Jun 25, 2026 · Backend Development

SpringBoot + WeChat Pay V3: Architecture for Million-Concurrent Payments

The article explains how to build a production‑grade, million‑concurrent payment pipeline with SpringBoot and WeChat Pay V3, covering the new security model, state‑machine design, idempotent handling, decoupled architecture, compensation mechanisms, and operational best practices such as connection‑pool tuning, observability, and fault‑tolerant deployment.

ObservabilityPayment ArchitectureSpringBoot
0 likes · 56 min read
SpringBoot + WeChat Pay V3: Architecture for Million-Concurrent Payments
Cloud Architecture
Cloud Architecture
Jun 25, 2026 · Backend Development

Four Production‑Grade Defenses Against Redis Cache Penetration in High‑Concurrency Microservices

The article explains how non‑existent data amplified by high concurrency can cause cache penetration, distinguishes it from cache breakdown and avalanche, and presents a layered defense—entry validation, Bloom filter existence checks, negative caching, and concurrent‑request convergence—plus practical code, metrics, and operational checklists for robust microservice deployments.

Bloom filterCache PenetrationNegative Cache
0 likes · 28 min read
Four Production‑Grade Defenses Against Redis Cache Penetration in High‑Concurrency Microservices
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 25, 2026 · Backend Development

Why Nginx Can Handle Tens of Millions of Requests

The article explains how Nginx’s event‑driven, asynchronous non‑blocking model, master‑worker multi‑process design, efficient I/O multiplexing (epoll/kqueue), and lightweight resource‑control architecture enable it to sustain extremely high concurrency with minimal overhead.

AsynchronousI/O multiplexingevent-driven
0 likes · 5 min read
Why Nginx Can Handle Tens of Millions of Requests
Cloud Architecture
Cloud Architecture
Jun 23, 2026 · Databases

Why Redis Handles Millions of Concurrent Requests: Event Loop and Cluster Design

Redis sustains millions of concurrent operations not merely because it is single‑threaded, but thanks to its non‑blocking event‑loop I/O, compact in‑memory data structures, serialized command execution that eliminates lock contention, and robust production features such as replication, sharding, persistence, observability and governance.

ClusterLua ScriptingRedis
0 likes · 40 min read
Why Redis Handles Millions of Concurrent Requests: Event Loop and Cluster Design
Cloud Architecture
Cloud Architecture
Jun 22, 2026 · Backend Development

Dubbo vs Spring Cloud: Deep Dive for Billion‑Scale Microservice Architecture

The article examines how to choose between Dubbo and Spring Cloud for high‑traffic microservice systems, analyzing communication models, thread and connection handling, governance capabilities, real‑world e‑commerce scenarios, and provides practical guidance on combining HTTP gateways, RPC, and asynchronous messaging for scalable, resilient architectures.

DubboKubernetesService Governance
0 likes · 32 min read
Dubbo vs Spring Cloud: Deep Dive for Billion‑Scale Microservice Architecture
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 22, 2026 · Operations

How to Tune Nginx Kernel Parameters for Up to 10× Performance Boost

The article walks through a step‑by‑step Nginx performance tuning guide, covering worker_processes and worker_connections settings, Linux file‑descriptor limits, sysctl tweaks such as net.core.somaxconn and tcp_max_syn_backlog, explicit listen backlog, and zero‑copy sendfile with tcp_nopush/tcp_nodelay to dramatically increase throughput and lower CPU usage.

Performance Tuninghigh-concurrencykernel parameters
0 likes · 4 min read
How to Tune Nginx Kernel Parameters for Up to 10× Performance Boost
Smart Era Software Development
Smart Era Software Development
Jun 22, 2026 · Artificial Intelligence

Constrained Autonomy: An Agentic Architecture Scaling to Hundreds of Thousands of Creators

The talk details a multi‑agent system for AI video creation that tackles orchestration uncertainty, fault irrecoverability, and quality attribution by applying a "constrained autonomy" principle, implementing a six‑layer architecture, high‑concurrency optimizations, comprehensive observability, and layered quality gates to support hundreds of thousands of simultaneous creators.

AI video generationAgentic ArchitectureObservability
0 likes · 12 min read
Constrained Autonomy: An Agentic Architecture Scaling to Hundreds of Thousands of Creators
Deepin Linux
Deepin Linux
Jun 22, 2026 · Backend Development

Memory Pool vs Object Pool: When to Choose and How to Build One from Scratch

The article explains why high‑concurrency programs suffer from memory fragmentation and system‑call overhead, compares memory pools and object pools, outlines their distinct use‑cases, provides step‑by‑step C and C++ implementations, and highlights optimization tips and common pitfalls.

C++Memory poolThread Safety
0 likes · 20 min read
Memory Pool vs Object Pool: When to Choose and How to Build One from Scratch
Code Farming
Code Farming
Jun 20, 2026 · Backend Development

How This Architecture Handles Tens‑Fold Traffic Spikes Without Crashing

The article breaks down a complete flash‑sale system into four phases and explains how Redis distributed locks, CDN static pages, Nginx rate limiting, message‑queue peak shaving, and sharding together prevent overselling, crashes, and lost orders even when traffic surges dozens of times.

Message QueueRedisflash sale
0 likes · 6 min read
How This Architecture Handles Tens‑Fold Traffic Spikes Without Crashing
Cloud Architecture
Cloud Architecture
Jun 20, 2026 · Backend Development

Beyond Nearby Users: Building a Millisecond‑Level Real‑Time Dispatch System with GeoHash and Spring Boot

This article dissects the architecture, algorithms, and production practices behind a millisecond‑level real‑time dispatch system that uses GeoHash for spatial indexing, Spring Boot for service orchestration, Redis GEO for fast candidate selection, and a series of scoring, atomic reservation, and observability techniques to handle millions of riders under high concurrency.

ObservabilityRedis GEOSpring Boot
0 likes · 36 min read
Beyond Nearby Users: Building a Millisecond‑Level Real‑Time Dispatch System with GeoHash and Spring Boot
ZhiKe AI
ZhiKe AI
Jun 19, 2026 · Backend Development

From 1 ns to 10 ms: Why Caching Exists and Why It Keeps You Up at Night

The article explains why caching is indispensable—from nanosecond‑level CPU caches to millisecond‑level disks—covers the classic pitfalls of penetration, breakdown and avalanche, and walks through consistency strategies such as Cache‑Aside, delayed double‑delete, and Canal‑based binlog syncing for high‑concurrency systems.

Cache AsideCache ConsistencyCanal
0 likes · 13 min read
From 1 ns to 10 ms: Why Caching Exists and Why It Keeps You Up at Night
samdeepthink
samdeepthink
Jun 18, 2026 · Backend Development

Designing a Billion‑User Payment System: Final Architecture Review

This article reviews the end‑to‑end design of a payment platform that handles 500,000 daily orders, detailing the three‑layer gateway‑orchestration‑base architecture, independent channel services, reconciliation mechanisms, and how business constraints drive each architectural decision.

Orchestrationgatewayhigh-concurrency
0 likes · 15 min read
Designing a Billion‑User Payment System: Final Architecture Review
Architecture & Thinking
Architecture & Thinking
Jun 18, 2026 · Backend Development

How to Scale a Flash‑Sale System from Zero to 1 Million QPS: A Step‑by‑Step Architecture Guide

This article dissects the evolution of a flash‑sale system from a simple monolithic controller to a cloud‑native, micro‑service architecture that can handle over one million requests per second, detailing traffic‑shaping, multi‑level caching, async processing, and inventory‑consistency techniques.

Distributed ArchitectureKubernetesMessage Queue
0 likes · 18 min read
How to Scale a Flash‑Sale System from Zero to 1 Million QPS: A Step‑by‑Step Architecture Guide
Subtle Storm
Subtle Storm
Jun 17, 2026 · Backend Development

What QPS Level Is Considered High Concurrency?

The article defines QPS, explains that high concurrency has no absolute threshold, and provides typical QPS ranges for various scenarios—from small internal systems to national‑scale apps—along with the architectural measures needed at each level.

QPSScalingdistributed systems
0 likes · 6 min read
What QPS Level Is Considered High Concurrency?
Cloud Architecture
Cloud Architecture
Jun 17, 2026 · Backend Development

Nginx Unified Gateway Deep Dive: Multi‑Domain, Dynamic Routing, and Ten‑Million Concurrency Load Balancing

This article analyses how Nginx evolves from a simple reverse proxy to a unified edge gateway, covering multi‑domain management, dynamic routing, high‑concurrency capacity planning, load‑balancing algorithms, TLS handling, observability, Kubernetes deployment, and practical production pitfalls.

KubernetesObservabilityOpenResty
0 likes · 35 min read
Nginx Unified Gateway Deep Dive: Multi‑Domain, Dynamic Routing, and Ten‑Million Concurrency Load Balancing
Subtle Storm
Subtle Storm
Jun 15, 2026 · Backend Development

Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems

The article breaks down how caching reduces repeated slow‑resource access, rate limiting protects systems from overload, smoothing (peak shaving) buffers burst traffic with queues, and idempotency prevents duplicate operations, using a milk‑tea shop analogy to illustrate each technique’s role in high‑concurrency environments.

Peak ShavingSystem Designbackend
0 likes · 7 min read
Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 15, 2026 · Operations

Designing Million‑QPS Architecture: LVS + Nginx + Keepalived Three‑Layer Load Balancing

The article explains how to build a million‑request‑per‑second system by combining LVS, Nginx, and Keepalived in a three‑layer load‑balancing architecture, detailing each layer’s responsibilities, configuration snippets, and kernel tuning parameters that ensure high throughput and seamless failover.

KeepalivedLVShigh-concurrency
0 likes · 5 min read
Designing Million‑QPS Architecture: LVS + Nginx + Keepalived Three‑Layer Load Balancing
Cloud Architecture
Cloud Architecture
Jun 12, 2026 · Backend Development

1 Million QPS Coupon‑Grab System: Distributed Rate Limiting, Stock Capping, and CAP Trade‑offs

The article explains how a production‑grade coupon‑grab service can survive millions of requests per second by treating rate limiting as a business admission layer, separating stock capping from throttling, making explicit CAP trade‑offs, and implementing a hybrid Redis‑based token‑bucket limiter with local fallback, monitoring, and deployment best practices.

CAP theoremKubernetesRedis
0 likes · 28 min read
1 Million QPS Coupon‑Grab System: Distributed Rate Limiting, Stock Capping, and CAP Trade‑offs
Cloud Architecture
Cloud Architecture
Jun 10, 2026 · Backend Development

How to End Duplicate Consumption in RocketMQ with Idempotence and High‑Concurrency Architecture

The article explains why RocketMQ inevitably delivers duplicate messages under at‑least‑once semantics, analyzes root causes in producer, broker and consumer stages, and presents a production‑grade idempotent solution that combines business keys, Redis caching, Redisson locks, a MySQL idempotent table, AOP interception, and comprehensive monitoring to guarantee exactly‑once business outcomes even under high concurrency and Kubernetes graceful shutdown.

JavaMonitoringRedis
0 likes · 34 min read
How to End Duplicate Consumption in RocketMQ with Idempotence and High‑Concurrency Architecture
Cloud Architecture
Cloud Architecture
Jun 8, 2026 · Backend Development

Why Fixed‑Window Rate Limiting Fails in High‑Concurrency: Full Guide to Three Production‑Ready Approaches

The article explains why the simple fixed‑window counter is a hidden trap for high‑traffic systems, outlines five essential questions for production‑grade rate limiting, and compares three practical deployment patterns—single‑node Guava token bucket, Redis‑based distributed sliding window, and Sentinel‑driven microservice governance—complete with code and operational tips.

GuavaRedisSentinel
0 likes · 44 min read
Why Fixed‑Window Rate Limiting Fails in High‑Concurrency: Full Guide to Three Production‑Ready Approaches
Cloud Architecture
Cloud Architecture
Jun 5, 2026 · Backend Development

RocketMQ 4.x Deep Dive: Send Mechanics, Thread Model & High‑Concurrency

This article explains why a RocketMQ producer is more than a simple send API, detailing its role in system throughput, consistency and fault isolation, and walks through sending principles, thread models, high‑concurrency design, retry strategies, back‑pressure mechanisms, outbox integration and production‑grade monitoring.

JavaMessage QueueOutbox
0 likes · 54 min read
RocketMQ 4.x Deep Dive: Send Mechanics, Thread Model & High‑Concurrency
Cloud Architecture
Cloud Architecture
Jun 4, 2026 · Databases

PostgreSQL vs MySQL: The Ultimate Engineering Guide to Database Selection

This comprehensive guide compares PostgreSQL and MySQL from an engineering perspective, covering business models, transaction semantics, concurrency, replication, scalability, operational costs, real‑world case studies, and a decision matrix to help teams choose the database that minimizes long‑term complexity and cost.

MySQLPostgreSQLReplication
0 likes · 38 min read
PostgreSQL vs MySQL: The Ultimate Engineering Guide to Database Selection
Architect Chen
Architect Chen
Jun 3, 2026 · Fundamentals

What TPS Threshold Defines High Concurrency? A Complete Guide

The article explains TPS (Transactions Per Second), shows how to calculate it with a concrete example, and outlines industry‑based concurrency tiers—from less than 100 TPS for ordinary systems up to 50,000+ TPS for billion‑level traffic platforms—helping readers understand what counts as high concurrency.

TPShigh-concurrencyperformance metrics
0 likes · 3 min read
What TPS Threshold Defines High Concurrency? A Complete Guide
Cloud Architecture
Cloud Architecture
Jun 2, 2026 · Databases

Advanced MySQL Production Practices: From Kernel Principles to High‑Concurrency Implementation

This guide presents a production‑grade MySQL playbook for senior developers, architects, and DB engineers, covering kernel internals, architecture governance, connection‑pool sizing, InnoDB tuning, index design, transaction and lock handling, replication, sharding, distributed transactions, change management, observability, security, cloud‑native deployment, and a complete best‑practice checklist.

InnoDBMySQLPerformance Tuning
0 likes · 42 min read
Advanced MySQL Production Practices: From Kernel Principles to High‑Concurrency Implementation
Subtle Storm
Subtle Storm
May 27, 2026 · Cloud Native

Designing High-Concurrency Systems: Lessons from a Sports Venue Management Platform

The article analyzes a real-world sports‑venue management platform, detailing how multi‑level caching, asynchronous processing with RocketMQ, database sharding, service splitting, and Kubernetes auto‑scaling together reduced average response time from 1200 ms to 150 ms, increased throughput eightfold, and achieved 99.95% availability under tens of thousands of QPS.

KubernetesRocketMQcaching
0 likes · 13 min read
Designing High-Concurrency Systems: Lessons from a Sports Venue Management Platform
Subtle Storm
Subtle Storm
May 26, 2026 · Cloud Native

Structuring a High-Concurrency System Design Paper for the 2026 Soft Exam

The article outlines a step‑by‑step framework for writing a high‑concurrency system design paper, covering project background, performance challenges, six concrete technical solutions—including multi‑level caching, async processing, rate limiting, database optimization, microservice decomposition, and elastic scaling—and how to quantify their impact with real data.

KubernetesRedisSystem Design
0 likes · 6 min read
Structuring a High-Concurrency System Design Paper for the 2026 Soft Exam
Lobster Programming
Lobster Programming
May 25, 2026 · Backend Development

Designing a System That Can Survive Sudden Spikes of One Million QPS

The article analyzes why simply adding Redis nodes cannot handle a sudden million‑QPS surge, then presents three practical solutions—key sharding, multi‑level caching with hot‑key detection, and distributed‑lock‑based fallback—to build a resilient high‑concurrency backend.

Cache ShardingHot Key DetectionMulti-Level Cache
0 likes · 7 min read
Designing a System That Can Survive Sudden Spikes of One Million QPS
AI Agent Super App
AI Agent Super App
May 20, 2026 · Operations

Enterprise‑Grade Nginx Configuration: From Binary Install to High‑Concurrency Production Deployment

This guide walks through installing Nginx via package manager or source compilation, explains core roles, provides a production‑ready configuration template, and details reverse proxy, load‑balancing strategies, health checks, high‑concurrency tuning, and HTTPS setup with self‑signed and Let’s Encrypt certificates.

LinuxSSLhigh-concurrency
0 likes · 13 min read
Enterprise‑Grade Nginx Configuration: From Binary Install to High‑Concurrency Production Deployment
Cloud Architecture
Cloud Architecture
May 17, 2026 · Backend Development

Production Design for Order Timeout Closure: RabbitMQ Delay Queues, Idempotent State Machine

This article presents a production‑grade architecture for automatically closing unpaid orders, detailing why simple scheduled tasks are insufficient, outlining high‑risk scenarios, defining five core objectives, comparing implementation options, and providing a complete RabbitMQ TTL + DLX solution with state‑machine idempotency, high‑concurrency handling, observability, and Kubernetes deployment guidance.

Spring Bootdistributed systemshigh-concurrency
0 likes · 40 min read
Production Design for Order Timeout Closure: RabbitMQ Delay Queues, Idempotent State Machine
samdeepthink
samdeepthink
May 17, 2026 · Backend Development

Final Episode: Building a Million‑Concurrent Product System

This article reviews the complete C‑end product system built for billions of users, covering demand analysis, Java migration, high‑concurrency read service design, launch safeguards, and a detailed list of proven caching and traffic‑isolation techniques validated in production.

EAV modelJava migrationRedis
0 likes · 9 min read
Final Episode: Building a Million‑Concurrent Product System
Cloud Architecture
Cloud Architecture
May 12, 2026 · Information Security

High-Concurrency Phone Encryption: Blind Index, KMS Management & Rotation

This article presents a production‑grade solution for encrypting phone numbers in high‑concurrency microservices, combining random AES‑GCM ciphertext with HMAC‑based blind indexes, multi‑version KMS‑managed keys, zero‑downtime key rotation, and detailed component designs to ensure confidentiality, exact searchability, and operational stability.

Database SecurityEncryptionJava
0 likes · 40 min read
High-Concurrency Phone Encryption: Blind Index, KMS Management & Rotation
Deepin Linux
Deepin Linux
May 12, 2026 · Backend Development

From Zero to One: Mastering Linux NAPI High‑Concurrency Packet Reception

This article explains why traditional interrupt‑driven network I/O stalls under high traffic, introduces the NAPI (New API) mechanism that combines interrupt wake‑up with batch polling, details its core data structures and scheduling functions, and provides step‑by‑step configuration and tuning guidance to achieve efficient, low‑latency packet processing on Linux servers.

LinuxNAPINetworking
0 likes · 35 min read
From Zero to One: Mastering Linux NAPI High‑Concurrency Packet Reception
Cloud Architecture
Cloud Architecture
May 9, 2026 · Backend Development

High‑Concurrency Flash‑Sale Blueprint: Redis Atomic Stock and Kafka Throttling

The article presents a production‑grade, scalable flash‑sale architecture that combines Redis atomic inventory deduction, Kafka asynchronous peak‑shaving, and careful database finalization, detailing each layer’s goals, pre‑filtering techniques, Lua scripting, idempotency, capacity planning, monitoring, and compensation strategies to prevent overselling and ensure reliability.

JavaKafkaRedis
0 likes · 31 min read
High‑Concurrency Flash‑Sale Blueprint: Redis Atomic Stock and Kafka Throttling
Cloud Architecture
Cloud Architecture
May 6, 2026 · Backend Development

Why Polling Breaks at Scale and How Spring Boot Webhooks Enable High‑Concurrency Event‑Driven Architecture

The article explains why traditional polling becomes unsustainable under high load, contrasts polling with webhook‑based event delivery, and provides a complete Spring Boot implementation—including outbox pattern, Kafka integration, retry logic, security, observability, and operational best practices—to build a production‑grade, scalable webhook platform.

KafkaObservabilityOutbox
0 likes · 36 min read
Why Polling Breaks at Scale and How Spring Boot Webhooks Enable High‑Concurrency Event‑Driven Architecture
AI Explorer
AI Explorer
May 2, 2026 · Backend Development

Building a High‑Concurrency DeepSeek Middleware with Go

The ds2api project, written in Go, offers a high‑concurrency, plugin‑based middleware that standardizes and converts various AI model APIs into DeepSeek‑compatible requests, delivering tens of thousands of conversions per second with millisecond latency and a simple three‑step setup.

AI infrastructureDeepSeekGo
0 likes · 6 min read
Building a High‑Concurrency DeepSeek Middleware with Go
Cloud Architecture
Cloud Architecture
May 1, 2026 · Backend Development

Production Nginx for 10M+ QPS: Rate Limiting, Load Balancing, WebSocket, gRPC, CDN

This guide details how to build a production‑grade Nginx edge layer capable of handling over ten million queries per second, covering traffic shaping, connection reuse, multi‑level caching, sophisticated rate‑limiting, load‑balancing algorithms, WebSocket and gRPC handling, dynamic configuration, observability, container deployment, and migration paths to API gateways or service meshes.

KubernetescachinggRPC
0 likes · 52 min read
Production Nginx for 10M+ QPS: Rate Limiting, Load Balancing, WebSocket, gRPC, CDN
LuTiao Programming
LuTiao Programming
Apr 29, 2026 · Backend Development

Java 2026 Learning Roadmap: The Proven Path to Double Your Salary

This article outlines a step‑by‑step Java learning roadmap—from core fundamentals to microservices, high‑concurrency, AI integration, and cloud‑native deployment—showing how targeted skill progression can dramatically boost both technical competence and earning potential.

AIJVMJava
0 likes · 9 min read
Java 2026 Learning Roadmap: The Proven Path to Double Your Salary
Java Architect Handbook
Java Architect Handbook
Apr 28, 2026 · Backend Development

SpringBoot + Disruptor: Achieving 6 Million Orders per Second with Ultra‑Fast Concurrency

This article explains why Disruptor—a lock‑free, high‑throughput Java queue from LMAX—was chosen over traditional brokers, details its core concepts such as RingBuffer, Sequence, and WaitStrategy, and provides a step‑by‑step SpringBoot demo that can handle up to six million orders per second without pressure.

DisruptorJavaMessage Queue
0 likes · 13 min read
SpringBoot + Disruptor: Achieving 6 Million Orders per Second with Ultra‑Fast Concurrency
Architect Chen
Architect Chen
Apr 28, 2026 · Backend Development

How High Must TPS Be for a Payment System to Be Considered High‑Throughput?

The article analyzes why payment systems require far higher transactions‑per‑second than typical web apps, outlines the challenges of distributed transactions under high load, and classifies TPS levels—from 1,000 daily to over 300,000—as benchmarks, citing Alipay’s Double 11 peak as an ultra‑high example.

Distributed TransactionsTPSbackend
0 likes · 3 min read
How High Must TPS Be for a Payment System to Be Considered High‑Throughput?
Cloud Architecture
Cloud Architecture
Apr 25, 2026 · Backend Development

Spring Boot & Tomcat Tuning for High Concurrency: 17 Techniques & 12 Key Parameters

This guide walks through a complete Spring Boot and Tomcat performance tuning workflow for high‑traffic services, covering thread‑model fundamentals, capacity planning, 17 practical engineering tricks, 12 essential Tomcat parameters, and strategies for graceful deployment, observability, and fault isolation.

JavaPerformance TuningSpring Boot
0 likes · 43 min read
Spring Boot & Tomcat Tuning for High Concurrency: 17 Techniques & 12 Key Parameters
Cloud Architecture
Cloud Architecture
Apr 25, 2026 · Databases

How a Phone Number Field Can Crash a 2B‑User Database – Architect’s Design Guide

A mis‑designed phone number column can silently degrade index performance, overload CPU, and cause a cascade of timeouts in a 2‑billion‑user system, but by treating the phone as a domain value object, using a normalized VARCHAR, aligning indexing rules, and applying consistent sharding and migration strategies, you can prevent the database from collapsing under high concurrency.

MySQLValue Objectdatabase-design
0 likes · 31 min read
How a Phone Number Field Can Crash a 2B‑User Database – Architect’s Design Guide
dbaplus Community
dbaplus Community
Apr 25, 2026 · Backend Development

From Zero to One: Complete Architecture Design for a Billion‑Scale Short‑Video System

This article dissects the end‑to‑end architecture of a billion‑scale short‑video platform, detailing layered design, core services such as upload, transcoding, recommendation, interaction, storage, and the key challenges of massive video storage, high‑concurrency streaming, low‑latency playback, and real‑time recommendation reliability.

System Architecturehigh-concurrencymicroservices
0 likes · 19 min read
From Zero to One: Complete Architecture Design for a Billion‑Scale Short‑Video System
Ray's Galactic Tech
Ray's Galactic Tech
Apr 24, 2026 · Backend Development

From Bottlenecks to a High‑Concurrency Medical Assistant with LangChain4j

This guide details how to design and implement a production‑grade, high‑concurrency medical AI assistant using LangChain4j, Spring Boot, Redis, and Kubernetes, covering architecture, RAG‑enhanced retrieval, controlled tool invocation, guardrails, idempotent transactions, scaling strategies and observability to ensure reliable, compliant patient interactions.

LangChain4jMedical AIRAG
0 likes · 33 min read
From Bottlenecks to a High‑Concurrency Medical Assistant with LangChain4j
Ray's Galactic Tech
Ray's Galactic Tech
Apr 24, 2026 · Backend Development

Self‑Healing Agents: Rebuilding a High‑Concurrency Travel System with Spring AI ReAct

This article details how a legacy travel‑booking service was transformed into a production‑grade, self‑healing agent system using Spring AI ReAct and multi‑tool coordination, covering architectural redesign, tool governance, error semantics, high‑concurrency safeguards, observability, security, and real‑world performance gains.

AgentReActSpring AI
0 likes · 31 min read
Self‑Healing Agents: Rebuilding a High‑Concurrency Travel System with Spring AI ReAct
JD Tech
JD Tech
Apr 23, 2026 · Backend Development

How JD Upgraded Its B‑Side Order Storage Architecture to Tackle Elasticsearch High‑Concurrency Pressure

Facing explosive merchant growth and soaring order volumes, JD redesigned its B‑side POP order storage by isolating large tenants, applying double‑hash routing, expanding clusters, buffering updates, and automating data archiving, ultimately delivering a high‑performance, scalable Elasticsearch platform that sustains massive traffic spikes.

Data SkewElasticsearchbackend architecture
0 likes · 16 min read
How JD Upgraded Its B‑Side Order Storage Architecture to Tackle Elasticsearch High‑Concurrency Pressure
mikechen
mikechen
Apr 23, 2026 · Backend Development

How Nginx Handles One Million Concurrent Connections: 4 Key Techniques

The article explains how Nginx sustains one million simultaneous connections by using asynchronous non‑blocking I/O, a robust multi‑process architecture, zero‑copy file transmission, and optimized caching strategies, with concrete configuration examples and performance reasoning.

asynchronous I/Ocachingepoll
0 likes · 4 min read
How Nginx Handles One Million Concurrent Connections: 4 Key Techniques
Architect Chen
Architect Chen
Apr 23, 2026 · Databases

How Redis Handles 1 Million Concurrent Connections: 4 Key Techniques

Redis achieves million‑level concurrency by keeping all data in RAM, using epoll/kqueue for non‑blocking I/O, employing highly optimized data structures with O(1) or O(log N) operations, and evolving from a single‑threaded core to optional multi‑threaded I/O, boosting throughput up to 12×.

Data StructuresI/O multiplexingIn-Memory
0 likes · 4 min read
How Redis Handles 1 Million Concurrent Connections: 4 Key Techniques
Cloud Architecture
Cloud Architecture
Apr 20, 2026 · Cloud Native

Industrial‑Grade Kubernetes Deployment: Zero‑Downtime Rolling Updates for Million‑Scale Concurrency

This article dissects a real‑world e‑commerce deployment failure, identifies common misconfigurations in Kubernetes Deployments, and presents a comprehensive, production‑ready guide that covers controller principles, rolling‑update sequencing, readiness semantics, capacity planning, HPA tuning, graceful shutdown, progressive delivery, GitOps integration, and a checklist of best‑practice patterns to achieve zero‑downtime releases capable of handling million‑level concurrent traffic.

GitOpsHPAKubernetes
0 likes · 43 min read
Industrial‑Grade Kubernetes Deployment: Zero‑Downtime Rolling Updates for Million‑Scale Concurrency
Cloud Architecture
Cloud Architecture
Apr 19, 2026 · Backend Development

Spring Boot Enterprise Guide: Implementing Four Unified Standards from API Contracts to High‑Concurrency Governance

This article presents a comprehensive, production‑grade guide for Spring Boot enterprise projects, detailing why and how to adopt four unified standards—response structure, exception handling, logging, and parameter validation—to ensure stable contracts, clear error semantics, observable systems, and robust input boundaries even under high concurrency.

API designLoggingSpring Boot
0 likes · 39 min read
Spring Boot Enterprise Guide: Implementing Four Unified Standards from API Contracts to High‑Concurrency Governance
MaGe Linux Operations
MaGe Linux Operations
Apr 16, 2026 · Operations

Mastering Nginx for High‑Traffic: Proven Tuning Steps for 10k+ QPS

This guide explains why the default Nginx configuration becomes a bottleneck under thousands of requests per second and provides a prioritized, production‑tested checklist of kernel, process, buffer, upstream, HTTP, and HA settings to dramatically improve throughput and latency.

ConfigurationLinux kernelcaching
0 likes · 24 min read
Mastering Nginx for High‑Traffic: Proven Tuning Steps for 10k+ QPS
Architect Chen
Architect Chen
Apr 16, 2026 · Operations

L4 vs L7 Load Balancing at Million‑Concurrency: Which Is More Stable?

The article compares Layer‑4 and Layer‑7 load‑balancing solutions for million‑concurrency scenarios, outlining their use cases, advantages, typical tools, performance characteristics, and why large enterprises often combine both to achieve high stability and flexible traffic control.

L4L7backend architecture
0 likes · 3 min read
L4 vs L7 Load Balancing at Million‑Concurrency: Which Is More Stable?