Skip to content
Tagged articles

high concurrency

500 articles · Page 2 of 5
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.

Outbox PatternPostgreSQLdatabase selection
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.

System ThroughputTPShigh concurrency
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.

Connection PoolInnoDBPerformance 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.

Horizontal ScalingKubernetesRocketMQ
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.

KubernetesRediscaching
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 ShardingMulti-level CacheRedis
0 likes · 7 min read
Designing a System That Can Survive Sudden Spikes of One Million QPS
Xiaolin Talks Programming
Xiaolin Talks Programming
May 21, 2026 · Backend Development

High-Performance QPS Monitoring in Spring Boot: Sliding Window, RingBuffer & LongAdder Deep Dive

This article details a production-ready QPS monitoring implementation for Spring Boot using sliding window algorithm with RingBuffer and LongAdder for high-concurrency safety, integrated with Micrometer for metrics exposure, covering algorithm design, code implementation, performance optimization, and distributed monitoring strategies.

Distributed MonitoringLongAdderMicrometer
0 likes · 19 min read
High-Performance QPS Monitoring in Spring Boot: Sliding Window, RingBuffer & LongAdder Deep Dive
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.

LinuxNginxSSL
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.

Distributed SystemsRabbitMQSpring Boot
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 SecurityJavablind-index
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.

LinuxNAPIPerformance Tuning
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.

Distributed SystemsJavaKafka
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.

KafkaOutboxSecurity
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.

KubernetesNginxWebSocket
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.

AICloud NativeJVM
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.

BackendTPSdistributed transactions
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.

Value Objectdatabase designhigh concurrency
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.

Video Streaminghigh 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.

LangChain4jRAGSpring Boot
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.

AgentBackendReact
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.

Backend ArchitectureCluster ScalingData Skew
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.

EpollNginxZero-Copy
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
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.

Backend ArchitectureL4L7
0 likes · 3 min read
L4 vs L7 Load Balancing at Million‑Concurrency: Which Is More Stable?
Architect Chen
Architect Chen
Apr 13, 2026 · Backend Development

How to Make Spring Cloud Gateway Handle a Million Concurrent Requests

This article explains how Spring Cloud Gateway leverages a reactive, non‑blocking architecture, OS‑level tuning, zero‑copy networking, and built‑in rate‑limiting and circuit‑breaker features to reliably sustain million‑level concurrent traffic in production environments.

NettyPerformance TuningSpring Cloud Gateway
0 likes · 4 min read
How to Make Spring Cloud Gateway Handle a Million Concurrent Requests
Cloud Architecture
Cloud Architecture
Apr 12, 2026 · Backend Development

How to Build an Atomic‑Level RocketMQ Transactional Message Wrapper for Production

This article explains why traditional distributed transactions fail, then details the core principles, state flow, and practical Java/Spring Boot implementation of an atomic‑level RocketMQ transactional message wrapper, covering schema design, idempotency, high‑concurrency handling, monitoring, and deployment for production‑grade microservices.

IdempotencyJavaRocketMQ
0 likes · 39 min read
How to Build an Atomic‑Level RocketMQ Transactional Message Wrapper for Production
LuTiao Programming
LuTiao Programming
Apr 10, 2026 · Backend Development

Master Payment Gateway Design: Multi‑Channel Aggregation, Smart Routing, and End‑to‑End Merchant Onboarding

The article explains how to build an enterprise‑grade payment gateway that unifies over 50 providers, performs millisecond‑level smart routing, handles failover, dynamic fee calculation, automated merchant onboarding, sharded storage, and comprehensive monitoring to sustain millions of transactions per day.

Distributed SystemsFailoverSmart Routing
0 likes · 10 min read
Master Payment Gateway Design: Multi‑Channel Aggregation, Smart Routing, and End‑to‑End Merchant Onboarding
Golang Shines
Golang Shines
Apr 8, 2026 · Backend Development

Deep Dive into FastCache: High‑Performance Local Cache for Go

FastCache is an open‑source Go local‑cache library that delivers extreme speed, zero GC pressure, thread safety, and a five‑method API, making it ideal for high‑concurrency services while providing clear usage guidelines, pitfalls, and suitable scenarios.

FastCacheGohigh concurrency
0 likes · 6 min read
Deep Dive into FastCache: High‑Performance Local Cache for Go
Architect Practice
Architect Practice
Apr 7, 2026 · Backend Development

The 8 Characters in a Text Message Reveal Hidden Challenges in Short‑Link System Design

This article walks through the end‑to‑end design of a lightweight short‑link service, covering why short links are needed, the choice of 302 redirects, key‑generation strategies (MurmurHash vs ID‑based base62), caching layers, security threats, scaling techniques, and practical pitfalls, all illustrated with concrete code and benchmark numbers.

Securitybase62 encodingcaching
0 likes · 25 min read
The 8 Characters in a Text Message Reveal Hidden Challenges in Short‑Link System Design
Cloud Architecture
Cloud Architecture
Apr 7, 2026 · Databases

MySQL Read‑Write Splitting: From Replication Basics to Production‑Ready Architecture

The article explains why simple SQL routing is insufficient for MySQL read‑write separation, details replication mechanisms, consistency challenges, and presents a comprehensive upgrade path—including static, dynamic, middleware, and hybrid routing strategies, configuration guidelines, monitoring, and high‑availability practices—to build a production‑grade, high‑concurrency architecture.

ShardingSphereSpring Bootarchitecture
0 likes · 44 min read
MySQL Read‑Write Splitting: From Replication Basics to Production‑Ready Architecture
Cloud Architecture
Cloud Architecture
Apr 6, 2026 · Backend Development

Spring Boot GeoJSON Optimization: From Transport Compression to Production‑Ready High‑Concurrency Architecture

This article presents a comprehensive, production‑grade guide for optimizing GeoJSON in Spring Boot services, covering data‑level reductions, binary encoding, compression strategies, architectural separation of external and internal traffic, caching layers, thread‑model tuning, observability, and a real‑world case study that cuts response times from 800 ms to 90 ms.

CompressionGeoJSONSpring Boot
0 likes · 40 min read
Spring Boot GeoJSON Optimization: From Transport Compression to Production‑Ready High‑Concurrency Architecture
Ray's Galactic Tech
Ray's Galactic Tech
Apr 4, 2026 · Backend Development

How to Build a High‑Concurrency Story Creation Platform with AgentScope Java

This article presents a step‑by‑step engineering guide for constructing a production‑grade, high‑throughput story generation platform using AgentScope Java, Spring Boot, Kafka, Redis, PostgreSQL, and Kubernetes, covering architecture, task modeling, DAG orchestration, code organization, scalability, observability, and deployment best practices.

JavaKafkaSpring Boot
0 likes · 39 min read
How to Build a High‑Concurrency Story Creation Platform with AgentScope Java
Ray's Galactic Tech
Ray's Galactic Tech
Apr 1, 2026 · Operations

High‑Availability Log Platform for Ten‑Million‑Level Concurrency

This article presents a comprehensive, production‑grade design for a log collection and analysis pipeline that can reliably handle ten‑million‑level concurrent writes by combining Filebeat, Redis, Logstash, and Elasticsearch with careful buffering, scaling, and observability strategies.

LogstashRediselk
0 likes · 32 min read
High‑Availability Log Platform for Ten‑Million‑Level Concurrency
Cloud Architecture
Cloud Architecture
Mar 28, 2026 · Backend Development

Spring Boot 3 Enterprise Development Guide: From Monolith to High‑Concurrency Distributed Architecture

This comprehensive guide walks through building a production‑grade e‑commerce order service with Spring Boot 3, covering everything from domain modeling and layered architecture to high‑concurrency safeguards, idempotent design, outbox messaging, distributed transactions, caching strategies, observability, security hardening, and cloud‑native deployment on Kubernetes.

Java 17KubernetesOutbox Pattern
0 likes · 44 min read
Spring Boot 3 Enterprise Development Guide: From Monolith to High‑Concurrency Distributed Architecture
Cloud Architecture
Cloud Architecture
Mar 26, 2026 · Backend Development

Spring Boot 3 + WebFlux High-Concurrency API Architecture: From Reactive Theory to Production

This comprehensive guide explains how Spring Boot 3 + WebFlux can handle massive concurrent API traffic by leveraging event‑loop I/O, Reactive Streams back‑pressure, and a layered architecture that separates ingestion, processing, storage, and dispatch, while covering pitfalls, performance tuning, observability, and production‑grade best practices.

SSESpring BootWebFlux
0 likes · 46 min read
Spring Boot 3 + WebFlux High-Concurrency API Architecture: From Reactive Theory to Production
Tech Freedom Circle
Tech Freedom Circle
Mar 25, 2026 · Backend Development

Cracking Alibaba’s 10M Orders Interview: Architecture Seven‑Suite + Heterogeneous Storage Solution

The article dissects Alibaba’s second‑round interview question on handling 10 million daily order queries, exposing why a single sharding answer fails and presenting a comprehensive architecture‑seven‑suite combined with heterogeneous storage (MySQL, HBase, ClickHouse, ES, Redis, MQ) to achieve high concurrency, low latency, and reliable data consistency.

Backend ArchitectureDistributed Systemsdatabase scaling
0 likes · 40 min read
Cracking Alibaba’s 10M Orders Interview: Architecture Seven‑Suite + Heterogeneous Storage Solution
Cloud Architecture
Cloud Architecture
Mar 24, 2026 · Backend Development

Spring Boot 3 Upgrade Path: JDK 17, AOT, Jakarta, and High‑Concurrency

Spring Boot 3 isn’t just a version bump—it mandates JDK 17, full Jakarta migration, AOT/Native support, and cloud‑native defaults, requiring developers to master modern Java language features, layered architecture, observability, caching, async processing, and high‑concurrency patterns to build production‑grade services.

AOTJava 17Spring Boot 3
0 likes · 47 min read
Spring Boot 3 Upgrade Path: JDK 17, AOT, Jakarta, and High‑Concurrency
IT Services Circle
IT Services Circle
Mar 11, 2026 · Backend Development

How to Build Scalable Python Back‑End Systems: Architecture, Async, and Ops

This article walks Python developers through designing high‑concurrency back‑end systems, covering architectural planning, modular project layout, async I/O with asyncio and FastAPI, load balancing with Gunicorn, database scaling, Celery task queues, caching, rate limiting, monitoring, and graceful shutdown techniques.

FastAPIPythonasyncio
0 likes · 20 min read
How to Build Scalable Python Back‑End Systems: Architecture, Async, and Ops
Cloud Architecture
Cloud Architecture
Mar 6, 2026 · Backend Development

Ultimate Guide to Designing Nginx Architecture for 1 Million QPS

This article walks through the complete engineering process—from Linux kernel tweaks and network stack tuning to Nginx master‑worker design, layered load‑balancing, zero‑copy I/O, rate‑limiting, and OpenResty Lua extensions—demonstrating how to build a production‑grade system that reliably handles one million queries per second.

Linux kernelNginxOpenResty
0 likes · 9 min read
Ultimate Guide to Designing Nginx Architecture for 1 Million QPS
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Mar 6, 2026 · Backend Development

How to Tune Nginx for Million‑Level Concurrency: Practical Configurations

This guide explains how to configure Nginx and Linux kernel parameters to support up to a million concurrent connections, covering worker processes, connection limits, system file‑descriptor settings, caching strategies, static file handling, and key reverse‑proxy directives with concrete code examples.

Linux kernelNginxPerformance Tuning
0 likes · 5 min read
How to Tune Nginx for Million‑Level Concurrency: Practical Configurations
Top Architect
Top Architect
Mar 3, 2026 · Backend Development

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

This article explains how to design a high‑concurrency ticket‑snatching service that can handle millions of requests by combining multi‑layer load balancing, weighted Nginx round‑robin, in‑memory stock with Redis‑backed global inventory, and Go’s native concurrency, complete with code samples and performance results.

GoNginxRedis
0 likes · 19 min read
How to Build a Million‑User Ticket‑Snatching System with Nginx, Redis, and Go
Selected Java Interview Questions
Selected Java Interview Questions
Feb 26, 2026 · Backend Development

Why Your Snowflake‑Like ID Generator May Duplicate IDs Under High Concurrency

The article analyzes a custom TraceIdGenerator that uses a simple AtomicInteger counter and IP‑based prefix, identifying how its reset logic and CAS competition can cause duplicate IDs in high‑concurrency scenarios, and proposes timestamp checks, larger ranges, retry mechanisms, and true Snowflake implementation as solutions.

Javaatomicintegerhigh concurrency
0 likes · 11 min read
Why Your Snowflake‑Like ID Generator May Duplicate IDs Under High Concurrency
ITPUB
ITPUB
Feb 22, 2026 · Backend Development

Designing a Cost‑Controlled “Cut‑One‑Knife” Promotion Engine for Massive Concurrency

This article breaks down the algorithm and architecture behind Pinduoduo's "cut‑one‑knife" promotion, explaining how dynamic pricing based on user value, Zeno’s paradox, Redis atomic operations, and anti‑fraud measures ensure users receive phones without the platform incurring losses even under massive traffic and bot attacks.

Anti-FraudDynamic PricingZeno paradox
0 likes · 8 min read
Designing a Cost‑Controlled “Cut‑One‑Knife” Promotion Engine for Massive Concurrency
Top Architect
Top Architect
Feb 18, 2026 · Backend Development

Building a Million‑User Ticket‑Spiking System with Nginx Load Balancing, Redis, and Go

This article explores how to design a high‑concurrency ticket‑spike service inspired by China’s 12306 platform, covering multi‑layer load balancing, local stock pre‑allocation, Redis‑based global inventory control, Go implementation details, and performance testing that demonstrates handling millions of simultaneous requests.

Redishigh concurrencyticketing system
0 likes · 21 min read
Building a Million‑User Ticket‑Spiking System with Nginx Load Balancing, Redis, and Go
Golang Shines
Golang Shines
Feb 17, 2026 · Backend Development

Building a Ten‑Million‑Scale WebSocket Push Service with Go

This article explains the trade‑offs between pull and push models, why Go is chosen for a high‑concurrency WebSocket server, provides complete Go and HTML code examples, and details architectural and performance optimizations needed to support millions of simultaneous connections and messages per second.

Bullet ScreenGoPerformance Optimization
0 likes · 12 min read
Building a Ten‑Million‑Scale WebSocket Push Service with Go
Code Wrench
Code Wrench
Feb 7, 2026 · Backend Development

How Go’s Netpoller Powers Millions of Connections – 5 Real‑World Cases

This article explains why Go programs often fail to reach C10M concurrency, analyzes five real‑world incidents, reveals the inner workings of Go's netpoller, and provides concrete code‑level optimizations, configuration tweaks, and load‑testing practices to achieve stable million‑connection services.

GoPerformance Tuninghigh concurrency
0 likes · 23 min read
How Go’s Netpoller Powers Millions of Connections – 5 Real‑World Cases
Tencent Cloud Developer
Tencent Cloud Developer
Feb 4, 2026 · Backend Development

How We Cut Server Costs by 82%: Refactoring a High‑Concurrency QQ Game Service from C++ to Go with Kafka

This article details the redesign of a core QQ game achievement service that suffered from low resource utilization and heavy CAS contention, describing how moving from a synchronous C++ implementation to an asynchronous Go‑Kafka pipeline eliminated lock conflicts, reduced server count by 82%, and dramatically improved latency and stability.

Kafkahigh concurrencyrefactoring
0 likes · 11 min read
How We Cut Server Costs by 82%: Refactoring a High‑Concurrency QQ Game Service from C++ to Go with Kafka
Java Tech Enthusiast
Java Tech Enthusiast
Jan 24, 2026 · Backend Development

How to Keep Database and Redis Cache Consistent Under High Concurrency

This article examines the common data‑consistency challenges when writing to both a database and a Redis cache, evaluates four write‑order strategies, and presents the most reliable approach—writing to the database first then deleting the cache—along with retry mechanisms using scheduled jobs, message queues, and binlog listeners.

Cache ConsistencyElastic-JobRedis
0 likes · 17 min read
How to Keep Database and Redis Cache Consistent Under High Concurrency
ITPUB
ITPUB
Jan 21, 2026 · Interview Experience

How to Design a Billion‑User Real‑Time Step Leaderboard for Interviews

This article breaks down the interview‑level system design of a WeChat‑style step leaderboard that must support over a billion users, handling massive write spikes, low‑latency friend ranking queries, storage scaling, and relationship complexity with a three‑part architecture using MQ, Redis, and MySQL.

KafkaLeaderboardRedis
0 likes · 8 min read
How to Design a Billion‑User Real‑Time Step Leaderboard for Interviews
Architect's Guide
Architect's Guide
Jan 21, 2026 · Backend Development

Designing a High‑Performance Flash Sale System: 7 Key Architecture Strategies

This article outlines a comprehensive backend architecture for flash‑sale (秒杀) systems, covering traffic control, Nginx and CDN setup, gateway rate‑limiting, Redis caching and distributed locks, message‑queue throttling, async order processing, hotspot isolation, and security measures to handle massive concurrent requests.

CAPTCHAflash salehigh concurrency
0 likes · 12 min read
Designing a High‑Performance Flash Sale System: 7 Key Architecture Strategies
SpringMeng
SpringMeng
Jan 21, 2026 · Industry Insights

Why Most Developers Struggle to Become Software Architects

Most programmers never become software architects because the role demands a distinct architectural mindset, extensive real‑world experience, and opportunities that are scarce in small teams, leading to a low proportion of architects and a career bottleneck for many engineers.

career developmentexperience gaphigh concurrency
0 likes · 5 min read
Why Most Developers Struggle to Become Software Architects
Su San Talks Tech
Su San Talks Tech
Jan 20, 2026 · Databases

How to Ensure Data Consistency Between Database and Cache in High‑Concurrency Scenarios

This article examines the common data‑consistency problems that arise when updating both a database and a cache under high concurrency, evaluates four typical write‑order strategies, and presents the most reliable solution—writing to the database first and then safely invalidating the cache using retry, scheduled tasks, MQ, or binlog listeners.

ConsistencyMQRetry
0 likes · 17 min read
How to Ensure Data Consistency Between Database and Cache in High‑Concurrency Scenarios
LuTiao Programming
LuTiao Programming
Jan 19, 2026 · Backend Development

How to Build a High‑Concurrency Flash‑Sale System with Spring Boot, Redis, and Lua

The article analyzes why flash‑sale systems often crash under extreme traffic and presents a step‑by‑step solution using Spring Boot, Redis, and Lua that prevents overselling, pre‑warms stock, applies token‑bucket rate limiting, executes atomic stock deductions, and decouples order creation asynchronously while adding monitoring and safety measures.

Atomic ScriptLuaRedis
0 likes · 9 min read
How to Build a High‑Concurrency Flash‑Sale System with Spring Boot, Redis, and Lua
Architect Chen
Architect Chen
Jan 18, 2026 · Backend Development

Mastering Million-Request Concurrency with Nginx, LVS, and Keepalived

This guide explains how to achieve million‑level concurrent request handling by combining Nginx, LVS, and Keepalived, detailing the architecture layers, load‑balancing design, high‑availability configuration, and practical sample configurations for each component in modern large‑scale web services.

KeepalivedLVSNginx
0 likes · 4 min read
Mastering Million-Request Concurrency with Nginx, LVS, and Keepalived
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 16, 2026 · Backend Development

Why Bigger Connection Pools Fail Under High Concurrency and What to Do Instead

Increasing a database connection pool size often worsens performance under massive traffic because the bottleneck lies in hardware limits and management overhead, so developers must adopt async processing, read‑write splitting, caching, sharding, and proper pool tuning to sustain high concurrency.

Asynchronous ProcessingBackend PerformanceConnection Pool
0 likes · 4 min read
Why Bigger Connection Pools Fail Under High Concurrency and What to Do Instead
Tech Freedom Circle
Tech Freedom Circle
Jan 16, 2026 · Interview Experience

Crack JD Interview: Master Singleton, Factory, Strategy, Template & Observer Patterns in 20 Minutes

This article offers a systematic, high‑concurrency‑focused walkthrough of core Java design patterns—including Singleton, Factory, Strategy, Template Method, and Observer—complete with code examples, pros and cons, selection guidelines, and interview‑ready explanations to help candidates impress interviewers and secure offers.

Design PatternsJavaTemplate Method
0 likes · 36 min read
Crack JD Interview: Master Singleton, Factory, Strategy, Template & Observer Patterns in 20 Minutes
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 14, 2026 · Backend Development

How to Handle Hot Account Deduction in High‑Concurrency Systems

This article examines strategies for low‑latency, consistent hot‑account updates under high concurrency, comparing optimistic DB locking, Redis‑based deduction with asynchronous merging, data sharding, and MQ‑driven batch processing, and also addresses read‑side solutions.

Asynchronous ProcessingOptimistic LockRedis
0 likes · 5 min read
How to Handle Hot Account Deduction in High‑Concurrency Systems
Raymond Ops
Raymond Ops
Jan 6, 2026 · Operations

How to Boost Nginx to Over 1 Million QPS: Real‑World Optimization Guide

This guide walks you through a complete Nginx high‑concurrency tuning process—from basic worker and TCP settings to kernel parameters, caching, SSL, and advanced techniques like DPDK and JIT—showing performance improvements from 80 k to over a million QPS with real‑world examples and scripts.

LinuxNginxOptimization
0 likes · 13 min read
How to Boost Nginx to Over 1 Million QPS: Real‑World Optimization Guide
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 2, 2026 · Backend Development

Implementing High‑Concurrency Circuit Breaking in Nginx with Lua

This guide explains how to use Nginx and OpenResty Lua scripts to implement rate limiting and circuit‑breaking for high‑concurrency services, detecting error rates and response latency, automatically opening and closing a 30‑second break window, and returning custom JSON responses when downstream services fail.

Circuit BreakingLuaNginx
0 likes · 5 min read
Implementing High‑Concurrency Circuit Breaking in Nginx with Lua
Ops Community
Ops Community
Dec 28, 2025 · Artificial Intelligence

Boost LLM Inference Speed: Build a High‑Concurrency vLLM Service with Best‑Practice Ops

This guide walks through the complete process of deploying a high‑throughput large language model inference service using vLLM, covering environment preparation, installation, configuration tuning, performance testing, real‑world case studies, monitoring, troubleshooting, and backup strategies for production‑grade deployments.

GPU optimizationLLM inferenceOpenAI API
0 likes · 44 min read
Boost LLM Inference Speed: Build a High‑Concurrency vLLM Service with Best‑Practice Ops
LuTiao Programming
LuTiao Programming
Dec 24, 2025 · Backend Development

Why High‑Concurrency Spring Boot APIs Fail and 6 Must‑Know Caching Strategies for 2026

The article explains that overwhelming request rates exceed database capacity, causing exponential latency, and presents six proven cache‑design techniques—including in‑process, Redis, multi‑level, cache‑aside, write‑through/write‑behind, and edge caching—to keep Spring Boot APIs stable, fast, and cost‑effective under high load.

Cache AsideCaffeineRedis
0 likes · 12 min read
Why High‑Concurrency Spring Boot APIs Fail and 6 Must‑Know Caching Strategies for 2026
DeWu Technology
DeWu Technology
Dec 15, 2025 · Backend Development

How Go Powers High‑Concurrency, High‑Availability Systems: 5 Real‑World Scenarios

This article explores five typical high‑concurrency, high‑availability scenarios—gRPC microservice communication, real‑time WebSocket messaging, API‑gateway rate limiting and circuit breaking, Redis‑Stream task queues, and Redis RedLock distributed locks—detailing the problems, Go‑centric solutions, code implementations, and supporting theory.

GoWebSocketgRPC
0 likes · 47 min read
How Go Powers High‑Concurrency, High‑Availability Systems: 5 Real‑World Scenarios
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 9, 2025 · Backend Development

Boost Kafka to Over 1 Million Messages per Second: Metrics and Tuning Tips

This article explains what high concurrency means for Kafka, outlines key performance metrics such as QPS, TPS, throughput and latency, and provides concrete configuration and architectural techniques—including broker optimization, horizontal scaling, network batching, and zero‑copy—to achieve write rates exceeding one million records per second.

BackendDistributed SystemsKafka
0 likes · 4 min read
Boost Kafka to Over 1 Million Messages per Second: Metrics and Tuning Tips
Architecture & Thinking
Architecture & Thinking
Dec 8, 2025 · Backend Development

Master Flash Sale Systems: Backend Strategies for Millions of Requests

This article explains the unique challenges of flash‑sale systems—massive, short‑lived traffic spikes—and presents practical backend optimizations such as front‑end request filtering, Redis‑based atomic counters, streaming queues, safe database updates, and unit‑level isolation for global deployments.

Atomic OperationsRedisbackend optimization
0 likes · 8 min read
Master Flash Sale Systems: Backend Strategies for Millions of Requests
Architect's Journey
Architect's Journey
Dec 5, 2025 · Backend Development

Capacity‑Driven Microservice Architecture: Solving High‑Concurrency Challenges

The article explains how a capacity‑driven microservice architecture uses performance metrics like QPS, TPS, and latency as the primary split criterion, detailing design principles, module responsibilities, and practical benefits that enable systems to handle traffic spikes without service collapse.

capacity‑driven architecturedomain-driven designhigh concurrency
0 likes · 10 min read
Capacity‑Driven Microservice Architecture: Solving High‑Concurrency Challenges
Architect's Journey
Architect's Journey
Dec 1, 2025 · Backend Development

Designing Three‑High Systems: Practical Performance Tuning and Fault‑Tolerant Architecture

The article breaks down the design logic and implementation steps for high‑performance, high‑concurrency, and high‑availability systems, covering bottleneck identification, read/write optimization, three‑dimensional scaling, and concrete fault‑tolerance strategies to build resilient, scalable services.

Fault ToleranceHigh Availabilityhigh concurrency
0 likes · 15 min read
Designing Three‑High Systems: Practical Performance Tuning and Fault‑Tolerant Architecture
Tech Freedom Circle
Tech Freedom Circle
Nov 15, 2025 · Databases

How to Prevent Order Loss in a 100k TPS Flash Sale When the Master DB Crashes – 5 Practical Solutions

The article dissects a high‑traffic flash‑sale interview question—how to guarantee zero order loss at 100,000 TPS when the master MySQL instance fails—by explaining the underlying performance‑consistency conflict, the three skills interviewers assess, and presenting five concrete, code‑driven solutions ranging from MySQL parameter tuning to semi‑sync replication, local message tables, group replication, and Redis‑Kafka traffic shaping.

Data ConsistencyGroup ReplicationKafka
0 likes · 28 min read
How to Prevent Order Loss in a 100k TPS Flash Sale When the Master DB Crashes – 5 Practical Solutions
Ray's Galactic Tech
Ray's Galactic Tech
Nov 14, 2025 · Operations

Mastering Nginx Under High Load: Practical Tuning & Troubleshooting Guide

Learn how to identify and resolve common high‑concurrency bottlenecks for Nginx by optimizing OS limits, network stack, Nginx configuration, logging, reverse‑proxy settings, backend services, and hardware resources, with concrete commands, parameter values, and step‑by‑step troubleshooting procedures.

BackendSystem Optimizationhigh concurrency
0 likes · 6 min read
Mastering Nginx Under High Load: Practical Tuning & Troubleshooting Guide