This guide explains the complete load‑testing workflow—from defining objectives and selecting targets to monitoring key performance indicators, analyzing results, and calculating the backend QPS needed to meet service‑level expectations.
This guide outlines a step‑by‑step process for designing JMeter scripts, performing local and BlazeMeter sandbox tests, configuring consoles and engines, scaling to clusters, and using Master/Slave mode to achieve a smooth load test of 50 000 concurrent users, including monitoring and resource considerations.
This article details how a performance testing team at a major e‑commerce company designed and evolved full‑link load testing from zero to a mature, repeatable process, covering its definition, historical milestones, challenges during major sales events, and future optimization plans.
This article explains how to employ JMeter's pre‑processor (HTML Link Parser) and post‑processor (Result Status Action) to create dynamic URL requests, simulate concurrent users, handle error responses, and visualize results for performance testing of web services.
The TestPG load‑testing platform, built on a master‑slave architecture with Redis‑driven dynamic configuration, delivers fine‑grained, cluster‑ and interface‑level pressure control that automates load‑generator allocation, shortens holiday testing cycles to three days, and produces realistic traffic models for Gaode’s nationwide services.
TarsBenchmark is an open‑source, high‑performance microservice load‑testing tool from Tencent that uses a multi‑process, event‑driven architecture with connection reuse and lock‑free monitoring, supports extensible protocols via JSON test cases, and offers both single‑machine and cloud‑distributed testing, outperforming traditional tools like Apache Bench, Wrk, and JMeter.
Gaode’s TestPG platform solves full‑link load‑testing bottlenecks by unifying traffic capture with Iflow, converting logs into standardized corpora via a Flink pipeline, and applying corpus‑intelligence that extracts seasonal feature statistics and predicts distributions for precise, feature‑level throttling, enabling faster, more reliable testing and future autonomous optimization.
This article explains a practical fixed‑QPS load‑testing model for HTTP requests, provides reusable Java code for creating test tasks, and details two bug fixes—one for thread‑pool shutdown handling in asynchronous compensation threads and another for inaccurate request‑counting that caused over‑compensation.
This article details the design, implementation, and performance testing of a Go‑based backend that simulates a Spring Festival red‑packet system capable of handling up to 6 × 10⁴ QPS and one million concurrent connections, demonstrating how to achieve 10 billion request processing in a controlled environment.
This article explains the design and implementation of a Java‑based fixed QPS load‑testing framework, covering its multithreaded base class, concurrent executor, compensation thread, performance metrics collection, and provides source code links for practical use and further development.
Performance optimization is a continuous, data‑driven practice that monitors response time and concurrency, applies techniques such as indexing, caching, parallelism, and asynchronous processing, and in Youzan’s live‑streaming product‑detail case reduced bottlenecks by adding multi‑level caches, circuit‑breaker fallbacks, and parallel sub‑task aggregation.
This article describes iQIYI's payment team approach to full‑link load testing, covering background challenges, systematic problem exploration, preparation of test environments, traffic modeling, execution safeguards, practical results, and future plans to improve capacity verification and system reliability.
iQIYI’s payment team built a full‑chain load‑testing framework that isolates data, mocks dependencies, constructs realistic multi‑service traffic, and executes protected tests to expose bottlenecks, guide scaling and optimizations, and ultimately ensure reliable payment services during traffic spikes, while planning a unified automation platform.
This article walks through the design, parameterization, and Java implementation of load‑testing scripts for two related APIs—one that creates a resource and another that deletes it—covering special handling of duplicate IDs, method encapsulation with default arguments, concurrent execution, and visual result analysis.
This guide explains how to identify Nginx bottlenecks, apply a series of configuration and kernel tweaks—including worker processes, event model, connection limits, gzip, proxy timeouts, and sysctl settings—and then validate the improvements with Apache ab load testing to achieve up to 100 000 concurrent requests.
This article details the background, performance and stability requirements, strategic approach, and concrete initiatives—including full‑chain load testing, chaos engineering, monitoring, and targeted optimization projects—that were undertaken to boost the performance by over 300% and improve high‑availability of the continuation enrollment platform.
This guide walks you through creating JMeter scripts, performing local and sandbox tests, configuring consoles and engines, scaling to clusters, and leveraging master‑slave mode to reliably run load tests with over fifty thousand simultaneous users.
This guide details the end‑to‑end process for performing a 50,000‑user concurrent load test with JMeter and BlazeMeter, including script creation, local validation, sandbox execution, engine scaling, cluster testing, and Master/Slave configuration to achieve the required concurrency.
This article introduces the Hey load‑testing tool, explains how to install and run it with specific QPS settings, analyzes the resulting metrics and charts, and offers practical tips for identifying bottlenecks such as network bandwidth or CPU usage during capacity planning.
JMeter’s reported throughput can be misleading because it includes local processing time, especially when response validation such as regex extraction adds overhead, leading to significant underestimation of actual server load; the article demonstrates this with experiments and suggests micro‑benchmark corrections to obtain accurate results.
This article details a practical approach to building a single‑machine prototype that supports one million concurrent connections and processes up to 60,000 QPS, simulating the massive load of 100 billion WeChat red‑packet requests with Go, Linux, and custom monitoring tools.
Through systematic performance testing, caching strategy analysis, server configuration tuning, Elasticsearch shard optimization, and validator refactoring, the team transformed the recommendation service’s throughput from roughly 190 QPS to over 2,200 QPS, demonstrating how targeted backend optimizations can dramatically improve high‑concurrency applications.
This article describes the design, implementation, and performance testing of a simulated WeChat red‑packet service capable of handling up to 100 billion requests, detailing target load calculations, hardware and software choices, concurrency strategies in Go, monitoring tools, and experimental results across multiple QPS levels.
This article describes how Ctrip’s senior test engineer designed and executed SIP‑based load‑testing scenarios with SIPp to evaluate the call‑center system’s capacity, concurrency limits, IVR/PBX overflow handling, and geographic routing accuracy during peak travel periods.
The author shares a series of JMeter demos that leverage Groovy for context access, variable handling, command execution, request manipulation, regex extraction, cookie and header processing, and throughput error analysis, while recommending thorough documentation review and community interaction to deepen JMeter expertise.
This article explores VSCode’s modular architecture for building large‑scale IDEs, dives into micro‑kernel plugin patterns with Vue and Xigua Player, showcases UI animation trends, introduces ARCore Depth API, highlights Flutter’s desktop support, and reviews Node.js monitoring and load‑testing tools.
This article explains why API testing has become essential in modern agile and IoT‑driven development, outlines the API testing pyramid, covers HTTP and REST fundamentals, and provides practical guidance on selecting tools, creating functional and load tests, and ensuring early, rapid feedback.
This guide provides a step‑by‑step tutorial on using Apache JMeter for performance testing, covering JDK and JMeter installation, creating a complete test script for a Baidu search API, configuring thread groups, HTTP requests, listeners, assertions, executing the test, and analyzing the aggregate report results.
The article explains the distinct purposes and benefits of performance, stress, and load testing, showing how each practice helps identify bottlenecks, ensure stability under load, and improve overall software quality throughout the development lifecycle.
This article introduces the powerful nGrinder load‑testing tool, explains its architecture and advantages over JMeter, walks through controller and agent deployment, script creation, data preparation, TPS control, parameterization, test execution, result analysis, and advanced features for building a stable, scalable distributed performance‑testing environment.
This article walks through the challenges of load‑testing a phone‑binding feature that swaps between two number prefixes while preserving the original UID‑derived number, detailing validation rules, a configurable solution, test design, and the full Groovy‑based load‑test script.
This article explains how to build two Java load‑testing modes—quantitative and timed—by extending thread‑limit classes, managing GCThread lifecycle, sending HTTP requests with FanLibrary, and correctly cloning request objects to avoid bugs during multithreaded performance testing.
This article explains two load‑testing strategies—fixed‑iteration (quantitative) and fixed‑duration (timed)—and provides complete Java implementations, usage guidance, and a Gitee repository link for a multithreaded performance testing framework.
This article explains how to use JMeter to limit output bandwidth by configuring httpclient.socket.http.cps and httpclient.socket.https.cps, enabling realistic simulation of various mobile network speeds such as GPRS, 3G, 4G, Wi‑Fi, and Ethernet, and shows how to apply these settings via user.properties or command‑line parameters.
The article shares a series of JMeter demos that leverage Groovy for accessing the test context, retrieving SampleResult and previous sampler data, discusses the limited usefulness of thread scheduling via Groovy, highlights a discovered throughput discrepancy, and provides practical advice and links to related technical resources.
Load testing, which simulates thousands of real users, is crucial for uncovering performance bottlenecks that functional tests miss, and integrating automated load tests into every CI cycle helps prevent crashes, protect revenue, and ensure reliable software delivery.
The article reveals that JMeter often reports inflated throughput because it includes client‑side processing time—such as regex extraction and post‑processors—in its calculations, leading to misleading performance metrics unless corrected with micro‑benchmark adjustments.
This article details a backend engineering practice that simulates 100 billion shake‑red‑packet requests by building a single‑machine prototype supporting one million connections, achieving peak QPS of 60 k, and demonstrates the methodology, hardware setup, code design, monitoring, and performance analysis.
This tutorial shows how to use Groovy scripts inside JMeter to set and retrieve both thread‑local (private) and thread‑shared (global) variables, providing step‑by‑step configuration, code snippets, and sample console output for each case.
This guide details a step‑by‑step process for creating, debugging, and scaling JMeter scripts, performing sandbox tests on BlazeMeter, configuring engine user limits, building clusters, and using master‑slave mode to achieve a 50 k concurrent‑user load test.
This guide introduces the Siege HTTP/HTTPS load‑testing tool, explains how to install it on CentOS 7, details its configuration options and command‑line flags, and provides practical examples with performance metrics for benchmarking web services.
When real‑time response isn’t critical, asynchronous writes can boost throughput, but they introduce latency that may exceed user tolerances; this article explains the concept, highlights the delay issue, and provides a step‑by‑step Java‑based latency testing method using a custom task loop to measure write and read times.
This article describes how Tubi’s engineering team built and optimized a real‑time recommendation backend, using ScalaMeter microbenchmarks and wrk2 load testing to measure latency, throughput and error rates, and demonstrates scaling the service across multiple machines with custom scripts.
The article explains how Alibaba introduced systematic capacity planning, four‑stage capacity assessment, various single‑machine stress‑test techniques, and a full‑link stress‑testing platform to reliably handle the massive traffic spikes of the Double‑11 shopping festival, while also describing a flexible traffic‑control framework to prevent overload and avalanche effects.
This article details a practical experiment that reproduces the load of 100 billion WeChat red‑packet (shake‑and‑grab) requests by simulating 1 million concurrent users on a single machine, achieving peak QPS of 60 k and demonstrating the architectural choices, hardware setup, and monitoring techniques required for such high‑throughput backend systems.
This article explains how to conduct proportional load testing for a microservice that exposes several APIs by using a custom Java performance‑testing framework, covering request deep‑copy handling, MarkRequest cloning, and a complete code example that drives concurrent requests according to a 1:2:3 ratio.
This article explains how e‑commerce promotions differ from offline sales by offering lower participation thresholds and flexible discount tactics, outlines methods for estimating and handling traffic spikes, and provides detailed strategies for system capacity planning, load testing, monitoring, and incident response to ensure stable large‑scale promotional events.
This article summarizes the Tongtian Tower backend performance optimization experience, detailing background, achieved improvements of 10‑30%, optimization principles, testing methods, metric analysis, and concrete strategies such as RPC scheduling, JVM tuning, logging, thread‑pool and code refinements to enhance latency and throughput.
The article details a performance bottleneck investigation of an Erlang‑based service experiencing high CPU usage, describing the use of recon tools, pressure testing, analysis of Kafka and Nginx impacts, and the subsequent optimizations that doubled throughput to meet business requirements.
This article explains how to extend an existing Java performance‑testing framework by adding a fixed‑time mode alongside the traditional fixed‑count mode, detailing the design of ThreadBase, ThreadLimitTimes, ThreadLimitTime classes, demo implementations for HTTP requests, and key design considerations for low‑overhead timing and early termination.
This article guides readers through preparing gRPC RPC scripts, creating Java sampler code for JMeter, packaging the scripts, and executing load tests to evaluate RPC performance, providing step‑by‑step instructions and code examples for Java‑based testing.
The article details JD.com's coordinated effort to prepare for the 11.11 shopping festival by expanding load‑testing scale, improving cross‑team collaboration, and enhancing the ForceBot platform with traffic recording and replay capabilities to achieve more realistic and efficient full‑chain performance evaluations.
This article explains how to perform load testing for scenarios where each row can be updated only once, using a thread‑safe queue to supply unique parameters to concurrent threads, and provides complete Java code examples for both a global queue and per‑thread queues.
The article describes JD's traffic replication and replay platform, explaining its background, the concepts of traffic copying and replay, detailed platform architecture and features, normalised load testing workflow, dynamic regression testing, operational results, current limitations, and future improvement directions.
The article describes how Gaode handles the challenges of supporting over 100 million daily active users by applying capacity planning, traffic control, disaster recovery, monitoring, rehearsal, and a self‑built full‑link load‑testing platform that simulates realistic traffic, manages resources, and provides detailed reporting to guarantee system stability.
To guarantee stability for over 100 million daily users, Gaode combines capacity planning, traffic control, disaster recovery, monitoring, and pre‑plan drills with a self‑built full‑link load‑testing platform (TestPG) that replays realistic traffic in production‑like environments, isolates test loads, provides rapid configuration, detailed debugging, automated error capture, and comprehensive reporting, while planning future enhancements such as integrated topology monitoring, advanced pressure models, and confidence evaluation.
This guide shares practical steps to overcome TIME_WAIT port exhaustion on macOS and optimize Apache HttpClient settings for high‑concurrency load testing, including sysctl tweaks for maximum file descriptors, port range adjustments, connection‑pool parameters, timeout configurations, and a custom connection‑recycling thread, enabling over 20 k concurrent requests without bottlenecks.
The article explains two approaches for flexible performance testing on a head‑only Linux server—one using configuration files to assemble requests and another using Groovy scripts—detailing code implementations, command‑line execution, and deployment steps.
This article explains why shadow links are essential for safe load testing in model middle platforms, how to isolate traffic using shadow tables, and provides a step‑by‑step implementation guide including interface analysis, data preparation, nginx configuration, and risk considerations.
The article describes how to load‑test Dubbo queue‑add and queue‑delete methods by pre‑generating messages, storing them in a thread‑safe LinkedBlockingQueue, and driving concurrent requests with custom Java code while addressing data‑initialisation challenges during repeated runs.
This article explains how Baidu’s Noah time‑series database measures, plans, and protects capacity, detailing throughput metrics, estimation and load‑testing methods, and a water‑level model that drives reliable scaling and overload mitigation for massive monitoring workloads.
This article details Didi's 2016 full‑link load‑testing initiative, covering data‑isolation strategies, virtual driver/passenger tooling, trace‑based traffic marking, staged deployment tactics, and the operational insights gained from stress‑testing a massive ride‑hailing platform.
This guide walks you through the complete process of planning, scripting, locally testing, and scaling a load test to over 50,000 concurrent users using JMeter and BlazeMeter, covering script creation, sandbox configuration, engine sizing, cluster setup, and master‑slave orchestration.
The article details Didi's end‑to‑end load‑testing strategy—including online environment testing, data isolation with virtual orders, trace‑based traffic marking, and a distributed virtual driver/passenger tool—describing its design, deployment stages, findings, and future reliability applications.
MAXIM is Youzan’s distributed full‑link load‑testing engine built on Gatling, featuring a central control center, multiple load injectors, a GUI for test orchestration, data‑parameter binding, real‑time injector monitoring, automated reporting with historical retention, and extensible architecture supporting Dubbo and centralized InfluxDB logging.
Youzan’s full‑link load‑testing architecture combines a traffic generator, a data‑factory pipeline, and the Maxim platform to replay realistic e‑commerce user actions, tag and isolate test traffic via unified headers, route reads/writes to shadow storage, and integrate Gatling for capacity planning, degradation, alarm, disaster‑recovery and throttling drills.
This report details the background, objectives, environment, test plan, distributed JMeter setup, server monitoring, results, and analysis of a load‑testing effort aimed at identifying performance bottlenecks and validating reliability of a front‑end Node.js quality‑inspection service under increasing concurrent traffic.
Meituan’s smart‑payment team combats growing complexity and third‑party failures by implementing a stability‑building program that raises availability through flexible degradation, rapid recovery, and three core QA practices—fault drills, online full‑link load testing, and a continuous operation system that standardizes processes, visualizes metrics, and automates resilience checks.
From its humble 2009 launch to the 2018 tenth anniversary, Alibaba’s Double 11 shopping festival evolved through relentless technical challenges—system crashes, CDN bottlenecks, over‑selling bugs, and massive load‑testing innovations—offering a decade‑long case study in operations, scalability, and resilience for large‑scale e‑commerce platforms.
This article examines the evolution of tcpcopy’s architecture across three generations, comparing application‑layer and packet‑level request replication, and explains how each design balances testing realism, system impact, and operational complexity for high‑performance traffic replay.
This article outlines the evolution of Ctrip’s performance testing approaches across three generations, analyzes their limitations, and presents the design, architecture, data construction, request tracing, monitoring, and operational considerations of the fourth-generation full‑link testing platform, including case studies and future outlook.
This article explores how to maximize Java application performance by defining measurable goals, using load‑testing tools like Gatling, monitoring with APM solutions such as Retrace, applying code‑level optimizations, and tuning JVM, database, and architectural settings for scalable, efficient systems.
This article consolidates practical knowledge on system performance optimization, covering key metrics, load‑testing utilities, Linux monitoring commands, and JVM profiling tricks to help engineers pinpoint and resolve throughput, latency, CPU, disk, and network bottlenecks.
This article explains how to employ the open‑source ApacheBench (ab) tool to conduct load‑testing and dynamic monitoring of a Linux‑based load‑balancing module, detailing environment setup, command parameters, and result analysis for effective performance evaluation.
This article provides a comprehensive overview of performance testing, explaining its definition, key metrics such as throughput, response time and concurrent users, the relationship between these indicators, optimal testing timing, a step‑by‑step workflow from requirement analysis to reporting, and practical tips for effective load testing and system optimization.
This article explains why rate limiting is essential for flash‑sale (seckill) services, compares token‑bucket and leaky‑bucket algorithms, and provides practical configuration examples for Tomcat, Nginx, and OpenResty, along with testing methods and code snippets.
The article describes a production traffic replay system that records real user traffic, creates scalable pressure sources, supports both 4‑layer and 7‑layer protocols, and provides automated fail‑over and monitoring features to enable realistic functional and performance testing at large scale.
After a recent feature release caused a sharp decline in a key data metric, the team followed a systematic, fourteen‑step troubleshooting process—including verification, code review, DBA involvement, local debugging, environment comparison, logging, packet capture, service restarts, request mode changes, load testing, and partition resizing—to identify and resolve a Kafka‑related throughput bottleneck.
This article presents a comprehensive case study of Baidu Nuomi's online load‑testing methodology for high‑traffic marketing events, covering capacity estimation, test planning, execution, anti‑attack measures, platform architecture, and lessons learned to ensure system reliability and performance under peak loads.
This article explains the design of an extended NSQ message format, illustrates its application in load‑testing, service isolation, and channel‑level filtering scenarios, describes the NSQ migration proxy tool and Spark/Flume connectors, and outlines future enhancements such as flow control and batch subscription.
This article explains JD Finance's operational challenges in a rapidly expanding micro‑service environment and presents a comprehensive approach that combines offline and online load testing, precise capacity calculations, and intelligent root‑cause alert analysis using both rule‑based and machine‑learning techniques.
This article details how Xiaohongshu tackled rapid growth challenges by designing, implementing, and operating a full‑link performance testing platform in just two days, covering system architecture, testing models, collaborative deployment, capacity planning, and practical advice for teams seeking reliable e‑commerce load testing.
This article explains how to improve Java application performance by defining measurable metrics, using load‑testing tools like Gatling, monitoring with APM solutions such as Stackify Retrace, applying code‑level best practices, tuning JVM heap and garbage collection, optimizing JDBC access, and scaling the architecture.
This article explains the purpose of performance (stress) testing, compares four testing approaches, details the chosen proportional‑deployment strategy, and provides comprehensive preparation steps, script guidelines, metric analysis, and practical tips for ensuring system stability during large‑scale traffic spikes.
This article explains how Dada's order platform was refactored from a Python Flask service to a Java‑based microservice architecture, employing load testing, circuit breaking with Hystrix, and multi‑datacenter disaster recovery to reliably handle eight million orders in a single day during the Double‑11 shopping festival.
This article explains how to measure a system's load capacity, identifies key factors such as bandwidth, hardware, OS and application configurations, and provides practical optimization techniques for Linux, Tomcat, Nginx, MySQL, and Redis to handle high concurrency efficiently.
A detailed case study reveals how an out‑of‑memory (OOM) situation on a Linux server caused Tomcat to crash during load testing, explains the kernel's OOM killer behavior, and provides practical solutions such as enabling swap and tuning Apache limits.
This article examines JD.com’s 618 shopping festival performance, the deployment of unmanned delivery robots, and the design and architecture of the ForceBot full‑link load‑testing system that enabled precise capacity planning and bottleneck detection for massive e‑commerce traffic.
This article explains why load testing is essential, compares three popular tools—ab, wrk, and Locust—including their command‑line usage and key parameters, and offers practical tips and additional options for accurate performance testing.
This article explains Alibaba's four‑step capacity‑planning methodology, the various single‑machine load‑testing techniques, the design of a full‑link load‑testing platform for Double‑11, and the dynamic flow‑control framework that together ensure system stability during extreme traffic spikes.
This article explains how to design performance testing scenarios, covering test models, metrics, script preparation, concurrency calculations, pressure strategies, run times, delay settings, user termination, monitoring methods, and various typical scenario types such as baseline, load, mixed, capacity, large‑concurrency, stability and scalability tests.
This guide introduces St-load, a Linux‑based streaming load testing tool, and provides step‑by‑step instructions for installing, compiling, and using its RTMP, HTTP, and HLS testing features, including command‑line examples and parameter explanations for both push and pull scenarios.
This article demonstrates how to install and run load‑testing tools Artillery and Apache ab, explains their command‑line options, interprets the performance metrics they produce, and provides tips for handling system limits during high‑concurrency tests.
ForceBot is JD.com’s comprehensive full‑chain load‑testing platform that simulates user behavior across the entire purchase flow, isolates test traffic, leverages Docker‑based agents, GRPC services, and real‑time data analytics to identify bottlenecks, optimize resource planning, and support both routine and peak‑traffic scenarios.
This article recounts Alibaba's 7‑year journey of capacity planning for the massive Double 11 shopping festival, detailing early guesswork, the introduction of load‑testing, online and scenario‑based testing, traffic isolation, and full automation that enabled precise resource allocation across hundreds of services.
This article revisits the technical design and evolution of the 2015 Chinese New Year Gala "shake" activity, detailing how the backend architecture was progressively refined—from a simple prototype to a production‑grade system capable of handling tens of millions of concurrent requests—through resource pre‑download, access‑layer integration, load‑balancing, and robust fail‑over mechanisms.
This guide introduces the wrk HTTP load‑testing tool, explains its multithreaded and Lua‑scriptable architecture, walks through installation and command‑line usage, interprets key performance metrics, and demonstrates how to extend functionality with custom Lua scripts for advanced testing scenarios.
This report details the performance testing of the 360 Endpoint Security Management System, covering product overview, architecture, tool selection (favoring LoadRunner), test scenarios, script implementation, execution results, resource utilization, and analysis, concluding with insights on testing methodology and optimization.
This guide explains how to design and test high‑concurrency systems by choosing appropriate server architectures, load‑balancing, database clustering, caching layers, message queues, first‑level caches, and static data strategies to ensure smooth operation under heavy user traffic.
This article compares JMeter, LoadRunner, Locust, asyncio (Python) and Go-based load testing tools by measuring CPU, memory, Nginx response and TPS under varying concurrency levels, concluding that Go delivers the highest throughput while Python coroutines offer significant improvements over older Python versions.
