Skip to content
Tagged articles

high concurrency

500 articles · Page 3 of 5
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 13, 2025 · Backend Development

Designing High‑Concurrency Microservice Architectures: Splitting, Sharding, Rate Limiting, and Circuit Breaking

This guide explains how to build a million‑request‑per‑second microservice system by properly splitting business domains, partitioning data with vertical and horizontal sharding, applying robust rate‑limiting techniques, and implementing circuit‑breaking and degradation strategies to maintain stability.

Circuit Breakinghigh concurrencyservice splitting
0 likes · 6 min read
Designing High‑Concurrency Microservice Architectures: Splitting, Sharding, Rate Limiting, and Circuit Breaking
IT Services Circle
IT Services Circle
Nov 11, 2025 · Backend Development

How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System

An e‑commerce order system acts as the core connector linking users, merchants, payments, logistics and revenue, and this article dissects its three essential flows—forward, reverse and state transitions—while detailing the technical challenges and solutions for order creation, payment, fulfillment, cancellation, after‑sale, architecture, and data handling.

Distributed Systemse-commercehigh concurrency
0 likes · 19 min read
How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 6, 2025 · Cloud Native

How Spring Cloud Gateway Handles Millions of Concurrent Requests

Spring Cloud Gateway achieves ultra‑high concurrency through asynchronous non‑blocking I/O, minimal Netty event‑loop threads, horizontal scaling with load balancers, Redis‑based distributed rate limiting, and built‑in circuit‑breaker protection, ensuring stable performance even under massive traffic spikes.

Spring Cloud Gatewaycircuit breakerhigh concurrency
0 likes · 4 min read
How Spring Cloud Gateway Handles Millions of Concurrent Requests
NiuNiu MaTe
NiuNiu MaTe
Nov 5, 2025 · Backend Development

How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System

This article dissects the core processes, functional challenges, and architectural design of a high‑throughput, strongly consistent e‑commerce order system, covering forward and reverse flows, order creation, payment, fulfillment, cancellation, after‑sale handling, and the layered backend architecture that powers it.

Backend ArchitectureDistributed SystemsTransaction Consistency
0 likes · 21 min read
How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System
Three Knives
Three Knives
Oct 31, 2025 · Databases

Redisun 1.1.0: A Lightweight High‑Performance Java Redis Client and the Code‑World Feedback Loop

Redisun 1.1.0, a Java‑based lightweight high‑performance Redis client built on smart‑socket, introduces major upgrades in performance, command coverage, code quality and documentation, provides Maven integration and code examples, and demonstrates superior async and sync throughput compared with Redisson, Jedis and Lettuce in high‑concurrency benchmarks.

JavaRedis clientRedisun
0 likes · 9 min read
Redisun 1.1.0: A Lightweight High‑Performance Java Redis Client and the Code‑World Feedback Loop
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Oct 29, 2025 · Backend Development

Designing a Million‑Concurrent Backend: LVS, Nginx, and Spring Cloud Gateway

This article explains how to build a high‑performance, million‑concurrent backend architecture by combining LVS for L4 load balancing, Nginx for L7 routing, and Spring Cloud Gateway as a resilient microservice gateway, covering traffic distribution, gateway responsibilities, and fault‑tolerance mechanisms.

LVSgatewayhigh concurrency
0 likes · 6 min read
Designing a Million‑Concurrent Backend: LVS, Nginx, and Spring Cloud Gateway
Tech Freedom Circle
Tech Freedom Circle
Oct 29, 2025 · Backend Development

Combining RocketMQ Transaction Messages, Local Message Table, and XXL‑Job for 10‑100k QPS Distributed Transactions

This article presents a detailed design for a high‑concurrency (10‑100k QPS) distributed transaction solution that integrates RocketMQ transactional messages, an eBay‑style local message table, and XXL‑Job reconciliation to achieve eventual consistency while handling failures, retries, and data‑explosion challenges.

CAP theoremJavaMessage Queue
0 likes · 34 min read
Combining RocketMQ Transaction Messages, Local Message Table, and XXL‑Job for 10‑100k QPS Distributed Transactions
Xiao Liu Lab
Xiao Liu Lab
Oct 27, 2025 · Operations

Boost Nginx to 100k+ Concurrent Connections: Essential Linux Kernel Tweaks

This guide explains why the default Linux kernel limits hinder Nginx performance, lists eight crucial sysctl parameters to increase port ranges, file descriptors, and connection queues, and shows how to verify and safely apply the changes for high‑concurrency workloads.

Linux kernelhigh concurrencynetwork optimization
0 likes · 7 min read
Boost Nginx to 100k+ Concurrent Connections: Essential Linux Kernel Tweaks
Raymond Ops
Raymond Ops
Oct 27, 2025 · Operations

Master Linux Network Tuning for High-Concurrency: Practical Guide

This guide walks through a real‑world high‑concurrency Linux scenario, diagnosing TCP state bottlenecks, analyzing default kernel parameters, and providing step‑by‑step sysctl tweaks, queue and buffer adjustments, monitoring scripts, and stress‑test recommendations to dramatically improve connection handling and throughput.

LinuxPerformance Optimizationhigh concurrency
0 likes · 9 min read
Master Linux Network Tuning for High-Concurrency: Practical Guide
Tech Freedom Circle
Tech Freedom Circle
Oct 25, 2025 · Databases

Designing a 10 WQPS Redis Counter Component: A Systematic Timer Solution

This article presents a complete, step‑by‑step analysis of a high‑concurrency Redis counter component that supports up to 100 000 QPS, covering business pain points, architectural design, two core counting strategies, sharding, local batch optimization, code walkthroughs, and performance benchmark results.

AOPCounterRedis
0 likes · 33 min read
Designing a 10 WQPS Redis Counter Component: A Systematic Timer Solution
NiuNiu MaTe
NiuNiu MaTe
Oct 22, 2025 · Backend Development

How to Build a Lightning‑Fast, Stable Seckill System That Handles Millions of Requests

Learn how to design a robust, high‑performance seckill architecture that can endure millions of concurrent requests by breaking down business flow, defining precise technical metrics, and implementing a four‑layer system—access, traffic‑shaping, business logic, and data—using CDN, APISIX, Redis, RocketMQ, and MySQL with detailed code examples.

RocketMQTCCapixis
0 likes · 22 min read
How to Build a Lightning‑Fast, Stable Seckill System That Handles Millions of Requests
Tech Freedom Circle
Tech Freedom Circle
Oct 20, 2025 · Backend Development

Mastering JVM Tuning: Real-World Enterprise Case Study for Interview Success

The article walks through a high‑traffic video service that suffered GC spikes, details a systematic diagnosis of three JVM configuration flaws, evaluates four GC tuning schemes across load scenarios, resolves CMS‑related pauses, and presents concrete performance gains with metrics, code snippets, and visual charts.

CMSGC TuningJVM
0 likes · 28 min read
Mastering JVM Tuning: Real-World Enterprise Case Study for Interview Success
Liangxu Linux
Liangxu Linux
Oct 19, 2025 · Operations

Boost Linux Server Throughput: Practical TCP/IP Stack Tuning Guide

This article presents a comprehensive, step‑by‑step guide for Linux network performance optimization, covering real‑world issues, sysctl parameter tweaks for TCP and IP stacks, queue and interrupt tuning, high‑concurrency strategies, monitoring scripts, a detailed e‑commerce case study, best‑practice recommendations, and safety precautions.

BBRLinuxTCP tuning
0 likes · 13 min read
Boost Linux Server Throughput: Practical TCP/IP Stack Tuning Guide
dbaplus Community
dbaplus Community
Oct 16, 2025 · Backend Development

How to Build a Billion‑Scale Open Platform: Architecture, Caching, and Resilience

This article presents a step‑by‑step engineering guide for designing, evolving, and operating a high‑traffic open platform, covering three‑layer decoupled architecture, multi‑level caching, asynchronous message queues, distributed transaction models, high‑availability strategies, and phased rollout plans to sustain billions of daily API calls.

Distributed SystemsHigh AvailabilityOpen Platform
0 likes · 20 min read
How to Build a Billion‑Scale Open Platform: Architecture, Caching, and Resilience
Architecture Digest
Architecture Digest
Oct 8, 2025 · Backend Development

How Ticketing Platforms Handle Millions of Clicks Without Crashing

This article explains how modern ticketing systems achieve millisecond‑level response times under massive concurrent demand by combining client‑side defenses, API‑gateway signature verification, Redis atomic stock decrement, and message‑queue buffering, ensuring fairness, preventing bots, and protecting backend services from overload.

Message Queueapp securityhigh concurrency
0 likes · 10 min read
How Ticketing Platforms Handle Millions of Clicks Without Crashing
Architect
Architect
Oct 6, 2025 · Backend Development

Designing a High‑Performance Flash‑Sale System: Architecture & Best Practices

The article details a comprehensive flash‑sale system architecture covering seven key dimensions—including front‑end separation, Nginx gateway, Redis caching, MQ clustering, business logic, database sharding, and security measures—to achieve ultra‑high concurrency, low latency, and reliable order processing.

flash salehigh concurrencysystem architecture
0 likes · 12 min read
Designing a High‑Performance Flash‑Sale System: Architecture & Best Practices
Architect's Guide
Architect's Guide
Oct 1, 2025 · Backend Development

How to Build High‑Traffic, High‑Concurrency Systems: Key Principles & Practices

Designing high‑traffic, high‑concurrency systems requires careful planning across architecture, client optimization, CDN usage, clustering, caching, database tuning, and service governance, with principles such as statelessness, modularity, and fault‑tolerance to ensure scalability, reliability, and maintainability.

Backend Architecturecachingdatabase scaling
0 likes · 12 min read
How to Build High‑Traffic, High‑Concurrency Systems: Key Principles & Practices
Su San Talks Tech
Su San Talks Tech
Sep 30, 2025 · Operations

Master High-Concurrency Nginx: Proven Configs to Crush 502/504 Errors

Learn how to transform Nginx into a high‑concurrency powerhouse by addressing common 502/504 errors, optimizing worker processes, event and HTTP settings, fine‑tuning OS kernel parameters, implementing caching, rate‑limiting, load‑balancing, and monitoring scripts, with practical code examples and checklists.

LinuxNginxSystem Optimization
0 likes · 10 min read
Master High-Concurrency Nginx: Proven Configs to Crush 502/504 Errors
dbaplus Community
dbaplus Community
Sep 27, 2025 · Backend Development

How to Build a Billion‑User Real‑Time Step Leaderboard Like WeChat Sports

Designing a real‑time step leaderboard for billions of users requires tackling massive write spikes, fast friend‑based queries, scalable storage, and high availability; this guide outlines a three‑step architecture using asynchronous message queues, Redis ZSETs, and MySQL sharding to meet those challenges.

LeaderboardMessage Queuehigh concurrency
0 likes · 7 min read
How to Build a Billion‑User Real‑Time Step Leaderboard Like WeChat Sports
NiuNiu MaTe
NiuNiu MaTe
Sep 24, 2025 · Backend Development

How to Build a Fast, Reliable, and Cost‑Effective Like System

This article breaks down the design of a high‑traffic like service, detailing four core requirements—speed, accuracy, stability, and cost control—while recommending Redis, a message queue, and MySQL, and illustrating the full architecture from frontend to persistence with practical code examples and optimization tips.

Message Queuehigh concurrencysystem design
0 likes · 17 min read
How to Build a Fast, Reliable, and Cost‑Effective Like System
Tech Freedom Circle
Tech Freedom Circle
Sep 24, 2025 · Backend Development

Designing a US Presidential Election Voting System: 1M TPS, 10M QPS, Immutable and Non‑Duplicate Votes

This article presents a comprehensive architectural design for a high‑throughput US presidential voting platform that must handle 1 million transactions per second and 10 million queries per second while guaranteeing vote immutability, one‑person‑one‑vote enforcement, real‑time result aggregation, and scalable storage using microservices, Kafka, Redis, Bloom filters, and blockchain anchoring.

BlockchainBloom filterDistributed Systems
0 likes · 32 min read
Designing a US Presidential Election Voting System: 1M TPS, 10M QPS, Immutable and Non‑Duplicate Votes
Sanyou's Java Diary
Sanyou's Java Diary
Sep 22, 2025 · Backend Development

How to Build a Scalable Enterprise Unified Message Push System

This article explains why growing enterprises need a unified message‑push platform, outlines the core challenges such as multi‑channel integration, high concurrency, reliability, templating and extensibility, and then walks through a complete architecture design—including access, business, service and storage layers—to achieve a scalable, maintainable solution.

BackendMessage Pushenterprise
0 likes · 10 min read
How to Build a Scalable Enterprise Unified Message Push System
Su San Talks Tech
Su San Talks Tech
Sep 18, 2025 · Backend Development

Designing a Million‑QPS Rate Limiter for Backend System Interviews

This article walks through a complete, interview‑ready design of a high‑performance rate‑limiting system that can handle up to one million queries per second, covering requirements, core entities, algorithm choices, distributed state storage with Redis, scalability, high availability, latency optimization, hot‑key mitigation, and dynamic rule configuration.

Backend ArchitectureDistributed Systemshigh concurrency
0 likes · 29 min read
Designing a Million‑QPS Rate Limiter for Backend System Interviews
Architect's Guide
Architect's Guide
Sep 17, 2025 · Backend Development

How to Build a High‑Performance Flash‑Sale System: 7 Key Architecture Strategies

This article explains the characteristics of flash‑sale traffic and presents a comprehensive backend architecture—including Nginx static separation, Redis caching and locking, MQ buffering, rate‑limiting, async order processing, database sharding, captcha protection, and page optimization—to handle massive concurrent requests while ensuring security and reliability.

Nginxflash salehigh concurrency
0 likes · 11 min read
How to Build a High‑Performance Flash‑Sale System: 7 Key Architecture Strategies
Su San Talks Tech
Su San Talks Tech
Sep 15, 2025 · Backend Development

How to Build a Scalable Food Delivery System: Architecture, High Concurrency, and Real‑Time Dispatch

This article dissects the architecture of a high‑traffic food‑delivery platform, covering layered micro‑service design, core service implementations, smart dispatch algorithms, real‑time rider tracking, peak‑time scaling strategies, and practical solutions to common performance and reliability challenges.

BackendFood Deliveryhigh concurrency
0 likes · 18 min read
How to Build a Scalable Food Delivery System: Architecture, High Concurrency, and Real‑Time Dispatch
Su San Talks Tech
Su San Talks Tech
Sep 11, 2025 · Databases

Why Redis Handles Millions of Requests: Deep Dive into Its High‑Performance Architecture

This article explains how Redis achieves ultra‑high concurrency by combining a single‑threaded event‑driven core, highly optimized in‑memory data structures, efficient I/O multiplexing, smart memory management, asynchronous persistence, and scalable clustering, allowing it to comfortably serve hundreds of thousands of simultaneous requests.

Performance TuningPersistenceRedis
0 likes · 16 min read
Why Redis Handles Millions of Requests: Deep Dive into Its High‑Performance Architecture
Open Source Tech Hub
Open Source Tech Hub
Sep 10, 2025 · Backend Development

Build High‑Performance PHP RPC Services with Workerman‑JsonRpc

This guide introduces Workerman‑JsonRpc, a lightweight PHP RPC framework built on Workerman, detailing its key features, environment requirements, installation steps, synchronous and asynchronous client usage, server implementation, and built‑in monitoring capabilities for creating scalable network applications.

BackendJSON-RPCPHP
0 likes · 7 min read
Build High‑Performance PHP RPC Services with Workerman‑JsonRpc
Su San Talks Tech
Su San Talks Tech
Sep 8, 2025 · Backend Development

Why Online Payments Stall at Peak Hours and How Modern Backend Design Fixes It

This article dissects the architecture of modern online payment systems, explaining how layered, distributed designs handle millions of requests per second, ensure data consistency, prevent fraud, and recover from failures through robust routing, locking, reconciliation, and disaster‑recovery strategies.

Data ConsistencySecurityhigh concurrency
0 likes · 18 min read
Why Online Payments Stall at Peak Hours and How Modern Backend Design Fixes It
Architect
Architect
Sep 6, 2025 · Operations

Master High-Concurrency Nginx: Core Configs, Advanced Tuning, and Real-World Checklist

This guide walks you through the common high‑traffic pain points of Nginx, explains why configuration and tuning matter more than hardware, and provides step‑by‑step core, advanced, OS‑level, monitoring, and troubleshooting configurations to reliably handle tens of thousands of concurrent connections.

LinuxNginxPerformance Tuning
0 likes · 11 min read
Master High-Concurrency Nginx: Core Configs, Advanced Tuning, and Real-World Checklist
Architect Chen
Architect Chen
Sep 4, 2025 · Backend Development

How Nginx Achieves High Concurrency with Event‑Driven and Non‑Blocking I/O

This article explains Nginx's event‑driven architecture, asynchronous non‑blocking I/O, and master‑worker multi‑process model, showing how these techniques eliminate waiting, maximize resource utilization, and enable the server to handle massive concurrent connections efficiently.

BackendNginxevent-driven
0 likes · 4 min read
How Nginx Achieves High Concurrency with Event‑Driven and Non‑Blocking I/O
Su San Talks Tech
Su San Talks Tech
Sep 1, 2025 · Backend Development

Build a Scalable Short‑Video System: Architecture, Storage, and Real‑Time Recommendations

This article dissects the architecture of a modern short‑video backend, covering layered system design, core services such as video production, distribution, interaction, storage strategies, real‑time and offline recommendation engines, high‑concurrency streaming solutions, and practical techniques for cost control, scalability, and fault tolerance.

Backend Architecturehigh concurrencyreal-time recommendation
0 likes · 22 min read
Build a Scalable Short‑Video System: Architecture, Storage, and Real‑Time Recommendations
Ubiquitous Tech
Ubiquitous Tech
Aug 31, 2025 · Backend Development

Java Interview Simulation: Designing a Scalable E‑Commerce Transaction & Fulfillment Platform

The article walks through a detailed Java interview simulation where the candidate designs a high‑performance, microservice‑based e‑commerce transaction and fulfillment system, covering architecture decomposition, caching, concurrency control, distributed transactions, observability, AI‑driven recommendation, and a concrete career roadmap.

AICI/CDDistributed Systems
0 likes · 50 min read
Java Interview Simulation: Designing a Scalable E‑Commerce Transaction & Fulfillment Platform
Coder Life Journal
Coder Life Journal
Aug 29, 2025 · Backend Development

Designing High‑Concurrency Systems: Tips from a 10‑Year Java Veteran

The article defines high concurrency, explains how to locate bottlenecks and understand user traffic patterns, then outlines practical measures such as distributed architecture, clustering, caching, asynchronous queues, rate limiting, database tuning, preloading, and fault‑tolerant monitoring to build robust high‑throughput systems.

Asynchronous Processingcachingdatabase optimization
0 likes · 4 min read
Designing High‑Concurrency Systems: Tips from a 10‑Year Java Veteran
Su San Talks Tech
Su San Talks Tech
Aug 25, 2025 · Backend Development

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

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

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

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

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

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

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

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

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

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

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

batch processingconsumer optimizationhigh concurrency
0 likes · 5 min read
How to Diagnose and Fix Kafka Message Backlog in High‑Concurrency Environments
MaGe Linux Operations
MaGe Linux Operations
Aug 6, 2025 · Operations

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Kafka High-Concurrency Core Design Explained

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

KafkaPage Cacheasynchronous producer
0 likes · 4 min read
Kafka High-Concurrency Core Design Explained
MaGe Linux Operations
MaGe Linux Operations
May 26, 2025 · Operations

Master Linux Network Tuning for Million‑Connection High Concurrency

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

high concurrencynetwork-tuningtcp optimization
0 likes · 9 min read
Master Linux Network Tuning for Million‑Connection High Concurrency
Architect
Architect
May 16, 2025 · Industry Insights

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

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

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

Nginx High-Concurrency Optimization Techniques

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

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

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

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

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

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

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

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

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

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

Idempotencybackend designdistributed-lock
0 likes · 7 min read
Preventing Duplicate Orders under 100k QPS: Full‑Stack Strategies
Deepin Linux
Deepin Linux
Apr 18, 2025 · Backend Development

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

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

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

Ensuring Message Processing Once in High-Concurrency Scenarios

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

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

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

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

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

Designing High‑Concurrency Backend Architecture for E‑commerce Platforms

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

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

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

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

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

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

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

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

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

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

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

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

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

Asynchronous ProcessingRedis cachingbackend optimization
0 likes · 18 min read
Evolution and Optimization of Bilibili Membership Ticketing System for High‑Concurrency Scenarios
Architecture Digest
Architecture Digest
Mar 12, 2025 · Backend Development

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

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

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

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

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

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

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

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

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

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

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

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

Preface

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

cache optimizationhigh concurrencyinventory-management
0 likes · 10 min read
Preface
JD Cloud Developers
JD Cloud Developers
Jan 22, 2025 · Backend Development

Mastering High-Concurrency Inventory Deduction for Flash Sale Systems

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

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

Unveiling the Secrets Behind China’s 12306 Railway Ticketing Powerhouse

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Understanding High Concurrency in Nginx: Configuration Tips and Best Practices

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

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

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

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

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

Design and Implementation of an E‑commerce Coupon System

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

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

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

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

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

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

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

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

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

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

BackendDistributed Systemscaching
0 likes · 18 min read
How Ctrip Scaled Its Ticket Booking System for Flash‑Sale Events