This tutorial explains how to use RunnerGo to set different concurrency levels for each interface of a news app by assigning interface weights, demonstrating the calculation of mixed concurrency and providing step‑by‑step instructions with screenshots.
The article describes the background, architecture, tool selection, key features, implementation challenges (including Go code for TCP/WebSocket handling), and real‑world deployment of a distributed simulation load‑testing platform that supports dynamic QPS control, multi‑protocol testing, and end‑to‑end data verification.
The article outlines three common pressure‑testing challenges—how to extract test points, how to obtain realistic target metrics, and how to design test strategies—then demonstrates single‑scenario load, mixed‑business load, and long‑duration stability tests using JMeter with stepwise thread ramp‑up and metric analysis.
This guide explains how to prepare a Go environment, install and configure the goreplay (gor) tool, capture real HTTP traffic from production, and replay it in a test environment with options for filtering, scaling, looping, and real‑time playback to achieve accurate performance testing.
The article explains performance testing as a non‑functional testing activity within continuous testing, describes its various types, compares process/thread/coroutine execution models, evaluates tools like LoadRunner, JMeter and Locust, and outlines desired features for container‑friendly performance testing solutions.
Tencent’s cloud load‑testing platform simulates massive Chinese‑New‑Year traffic by offering concurrency and RPS modes, multi‑language test authoring, realistic data generation, and unified OpenTelemetry reporting, enabling early bottleneck detection, proactive scaling, and successful high‑load drills such as Mobile QQ and video services.
This article explains how micro‑enterprise SaaS leader Weimeng built a full‑link load‑testing platform to simulate real‑world traffic for major shopping festivals, detailing the challenges, architecture, capabilities, results, and future plans for ensuring system stability and performance at scale.
This guide explains what performance testing is, why it’s essential, the key metrics such as throughput, response time, and bandwidth, outlines a step‑by‑step testing process, compares load, stress, endurance and capacity testing types, and reviews popular tools like JMeter, LoadRunner and NeoLoad.
This article explains how Java architects should select appropriate MySQL database machine configurations, collaborate with DBAs for deployment, and conduct essential performance and load testing, covering QPS vs TPS, IOPS, throughput, latency, and other critical metrics for production environments.
The article explains why traditional load testing struggles with modern, scalable infrastructures and shows how integrating sidecar containers into Kubernetes can simplify traffic capture, enrich replay data, reduce operational overhead, and enable more realistic, automated load‑testing pipelines.
DeWu’s new full‑chain load‑testing platform replaces expensive 1:1 replica environments with a decentralized, container‑based system that isolates test data via middleware markers, supports multiple protocols (HTTP, Dubbo, gRPC, WebSocket, JDBC, Java), offers fixed‑QPS and thread modes, auto‑generates detailed reports, and achieves low CPU/memory usage while paving the way for future features such as data sanitization and dynamic throughput adjustment.
From kickoff meetings and traffic forecasting to load‑testing strategies, rate‑limiting designs, emergency runbooks, and post‑event retrospectives, this guide walks engineers through the complete technical workflow required to ensure a Double‑11‑scale e‑commerce promotion runs smoothly and safely.
This article explains the business‑driven need for regular load‑testing in e‑commerce, outlines the preparation steps, compares onsite, scheduled and hybrid testing approaches, and shares practical results and future plans for achieving efficient, low‑cost, and reliable performance verification.
The article shares a senior architect's experience improving a legacy multi‑service web system's performance by 3000% by fixing a DB connection leak, adopting tail‑latency metrics, and investing in load testing, monitoring, logging, and dedicated SRE resources.
This article shares a real‑world case study of how a hidden database‑connection leak in a pod’s health‑check caused severe latency, and outlines four key lessons on performance metrics, testing, legacy system maintenance, and the critical impact of every line of code.
This article explains what performance testing is, when to conduct it, typical scenarios, step‑by‑step execution—including requirements, test design, tool selection, script examples with Locust, result analysis, and key metrics such as throughput, response time, P90, and optimal concurrency.
This article details Bilibili's end‑to‑end full‑link load‑testing solution for its live‑stream gifting service, covering industry alternatives, the chosen architecture, a three‑stage automated testing framework, link analysis, configuration, validation, and practical case studies to ensure system stability under massive traffic spikes.
This article presents a comprehensive traffic verification platform that intercepts, records, stores, replays, and load‑tests online request flows to validate functional correctness and performance before cutting traffic to new order‑processing services, offering detailed design, implementation, and practical usage guidance.
This article walks through building a gRPC server and client in Java, then demonstrates four performance‑testing models—static thread, static QPS, dynamic thread, and dynamic QPS—detailing the code, configuration, and execution steps for each, while explaining why the blocking stub is preferred for metric collection.
Bilibili’s load‑testing platform evolved from ad‑hoc JMeter scripts to a fully automated, self‑service system (Platform 2.0) that uses a custom load client, adaptive scheduling, and flexible scenario modes—including traffic replay and data‑isolated testing—to efficiently stress‑test over a hundred microservices for large‑scale events, with further integration and circuit‑breaker enhancements planned.
A comprehensive catalog of performance testing articles ranging from Linux monitoring tools and test frameworks to concurrency utilities, distributed load testing strategies, QPS modeling and language-specific benchmark studies, providing developers with practical insights and techniques for optimizing system performance.
This article provides a thorough overview of server performance testing, covering fundamental concepts, the influence on users and revenue, key metrics, various test types, a step‑by‑step testing workflow, and a comparative analysis of popular performance testing tools.
This article explains the background, design, and core components of Havok—a full‑link load‑testing platform that replays production logs, supports traffic scaling, mock services, real‑time monitoring, isolation, and circuit‑breaker protection—to help enterprises evaluate capacity and improve reliability without polluting live data.
This guide shows how to download, configure, and run Apache JMeter on a Windows machine to generate 20,000 HTTP requests locally by setting up a thread group, adding an HTTP sampler, and using listeners such as the Aggregate Report to analyze the load‑test results.
This article explains how WeChat engineered a high‑concurrency backend to support billions of shake‑to‑receive red‑packet requests during the Spring Festival Gala, detailing the prototype system, challenges, iterative solutions, and the final production version that processed over 110 billion shakes with peak loads of 14 million requests per second.
This article presents a comprehensive performance testing case study of a multi‑table database query interface, detailing common performance metrics, response‑time classifications, step‑by‑step load‑test results, root‑cause analysis of CPU, memory, and connection‑pool bottlenecks, and demonstrates how tuning Druid’s maxActive and maxWait parameters optimizes throughput and reduces latency.
This article explains what load testing is, why it matters, the main testing types, essential terminology, compares popular tools, offers step‑by‑step guidance for selecting a tool, and presents detailed real‑world Java performance problem case studies with commands and analysis techniques.
This article explains how to describe current system load, choose appropriate load parameters, analyze Twitter's scaling challenges, compare relational and push‑based timeline designs, clarify latency versus response time, emphasize percentile monitoring, and evaluate vertical versus horizontal scaling and hybrid approaches for handling increasing traffic.
This article explains how the Havok full‑link load testing platform was designed and built to replay real traffic safely, provide capacity‑assessment data, support multiple test types, and offer real‑time monitoring and circuit‑breaker protection for large‑scale online services.
This article shares a real‑world case study of a company operating fifteen web applications, describing how a hidden DB‑connection leak in a pod liveness probe caused severe latency, how the issue was diagnosed and fixed, and the four key take‑aways for reliable performance engineering.
The presentation details Alipay's evolution through three stability phases—capacity, elastic cloud‑native architecture, and green computing—covering unit‑based deployment, elastic scaling, ServiceMesh, full‑chain load testing, intelligent monitoring, and the OceanBase distributed database, illustrating how these techniques achieved 99.99% availability during the 2021 Double‑11 peak.
This guide explains why mini‑programs need load testing, outlines three common testing scenarios, describes four test‑type designs, and provides step‑by‑step instructions for using Alibaba Cloud PTS to obtain platform tokens, configure APIs, and run stable, long‑duration pressure tests.
Integrating a dynamic load‑testing model into the OKR workflow dramatically streamlines performance testing by allowing flexible pressure control, manual intervention at safe thresholds, and reducing the fatigue and errors associated with traditional static ramp‑up strategies.
This article recounts a hiring manager’s interview with a candidate lacking high‑concurrency experience, then outlines the candidate’s self‑driven three‑stage practice—single‑machine optimization, load‑balanced testing, and middleware integration—providing concrete steps for engineers to acquire high‑concurrency expertise.
This article details a step‑by‑step engineering experiment that reproduces a high‑throughput "red‑envelope" service, outlining the required hardware, software stack, load‑generation logic, monitoring setup, and performance results for handling up to 6 000 QPS on a 100‑million‑user scale.
This article shares practical lessons from optimizing the performance of legacy web applications, covering how a hidden DB‑connection leak caused severe latency, why average latency is misleading, and the essential tools, testing, and team practices needed to keep services fast and reliable.
This collection compiles dozens of Chinese articles on performance testing, covering tools, frameworks, case studies, and techniques such as netdata monitoring, load generators, concurrency utilities, distributed testing, QPS modeling, and comparisons of JMeter, K6, Gatling, and FunTester.
After a sudden traffic surge exposed severe latency in a 15‑year‑old multi‑service web system, the team identified a DB connection leak in a health‑check probe, and through load testing, monitoring, logging, and dedicated SRE effort, they derived key operational lessons on performance optimization and maintenance of legacy applications.
After a traffic surge exposed severe latency in a 15-year-old multi-service web platform, we used monitoring to discover a DB-connection leak caused by a liveness probe, corrected it, and distilled four practical lessons on latency metrics, tooling, legacy maintenance, and code vigilance.
The article shares a real‑world case study of a legacy multi‑service web platform where traffic spikes exposed DB connection leaks, leading to a 90% response‑time bottleneck, and outlines four key takeaways about tail‑latency metrics, investing in tools and people, actively maintaining legacy systems, and treating every line of code as critical for performance.
This article walks through the design and practical implementation of a high‑throughput red‑envelope service capable of handling 10 billion requests, covering target load calculations, hardware and software choices, client‑server coordination, performance testing, monitoring, and key takeaways for building scalable backend systems.
This article shares hard‑won lessons from optimizing fifteen high‑load web applications, highlighting how a tiny DB‑connection leak in a pod probe caused severe slowdown and how fixing it, along with proper load testing, monitoring, and investment in tools and people, can dramatically improve system performance.
This article provides a comprehensive guide to game pressure testing, covering the full workflow from requirement communication and test planning to execution, performance analysis using tools like LuaProfiler, Perf, and VTune, and detailed result interpretation with case studies.
This article explains the theory and practice of game stress testing, covering four test types (server, client, third‑party services, cloud gaming), key performance indicators such as CPU, memory, network and log metrics, and the use of server and client robots to simulate real‑world load.
The 2021 year‑end summary details FunTester’s rapid growth, the expansion of its public account, major performance upgrades reaching over 100 k QPS, the design of a distributed testing framework, dynamic load models, log‑replay innovations, and the author’s deep dive into Go, Java and Groovy.
This article demonstrates how to use Postman for basic HTTP requests, ApacheBench and JMeter for load testing, and Java's CountDownLatch and Semaphore classes to simulate concurrent requests, providing step‑by‑step instructions, code examples, and configuration details for effective API performance testing.
This guide walks you through using Postman for basic API calls and concurrency testing, setting up ApacheBench on Windows, configuring and running JMeter for performance testing, and implementing custom load simulations in Java with CountDownLatch and Semaphore to understand thread coordination and bottlenecks.
This article details a step‑by‑step performance optimization of a Python backend service, covering requirement analysis, architecture redesign with caching and Redis queues, load‑testing results, TCP TIME_WAIT issues, and kernel parameter tweaks that ultimately raised throughput to 50,000 QPS with zero errors.
This guide surveys a range of open‑source tools for unified account management, automated server deployment, DNS services, performance testing, and host security, including LDAP, JumpServer, NIS, Fabric, Ansible, dnsmasq, pdnsd, ApacheBench, TCPcopy, PortSentry, fail2ban, and Google Authenticator, helping administrators streamline operations across Linux environments.
This article details the end‑to‑end preparation, execution, reporting, and retrospective of a large‑scale production‑environment load test for the Double 11 shopping festival, covering data preparation, QPS target calculation, multi‑scenario testing, issue analysis, and continuous improvement practices.
This article explains how to redesign the FunTester framework to enable real‑time pressure scaling by treating each multithreaded task as a manageable object, adding interrupt capabilities, and implementing global management for dynamic thread addition, removal, and cloning during load testing.
Full‑chain load testing uncovered a Redis large‑key bottleneck that saturated bandwidth, a memory‑leak caused by repeatedly registering shutdown hooks, and persistently high JVM heap usage, leading to solutions of key sharding with local caching, registering hooks only once, and adjusting heap size, physical memory, and alert thresholds.
This article details ZTO's evolution from traditional offline and online load‑testing approaches—highlighting their shortcomings—to a comprehensive full‑chain performance testing solution that uses JavaAgent probes, shadow resources, and a structured deployment and verification process to ensure safe, accurate production testing.
This article explains how to build traffic‑ratio models for GET APIs, scale them, and implement a random‑selection framework in Java/Groovy to quantitatively simulate real‑world request loads for both individual endpoints and whole services.
This article details the design and implementation of a dynamic pressure model for the FunTester performance testing framework, covering the goal of flexible load adjustments, core features, multithread synchronization using Phaser, code examples, a demo execution, console output analysis, and identified limitations.
This article documents a step‑by‑step performance optimization of a high‑traffic web module, covering requirement analysis, bottleneck detection in database and TCP connections, cache integration, load‑testing results, Linux kernel parameter tuning, and the final achievement of 50k QPS with sub‑60 ms latency.
The article reviews three common full‑chain load‑testing traffic models—business‑model based implementation, traffic recording and replay, and gray‑split routing—explaining their principles, advantages, challenges, and practical considerations for realistic performance testing.
This article explains high-fidelity load testing, outlines the technical breakthroughs of JD's ForceBot platform—including massive traffic generation, full‑domain traffic recording and replay for both public and internal networks—and showcases its successful deployment during the 618 and Double‑11 shopping events.
This article documents a Python service performance optimization journey, covering requirement analysis, environment setup, load testing, database bottleneck mitigation, caching, TCP time‑wait tuning, and kernel parameter adjustments that ultimately raised QPS to 50,000 with stable latency and zero errors.
This article details the final updates to the DCS_FunTester distributed testing framework, covering Gradle multi‑module configuration, dependency handling, result aggregation, task dispatch, health‑check endpoints, and registration optimizations with practical code examples in Java and Maven.
This document outlines a comprehensive SRE‑driven operational framework for ensuring stable, high‑availability online education services during peak summer and winter periods, detailing pre‑, during‑, and post‑maintenance phases, architectural principles, load testing, monitoring, capacity management, safety hardening, chaos engineering, incident response, and post‑mortem practices.
This guide explains how to plan, configure, and execute full‑link performance testing—including network architecture, testing objectives, environment isolation, platform setup, various load‑generation methods, monitoring, and post‑test analysis—to ensure reliable, scalable services under heavy traffic.
By illustrating how to replace simple HashMap caching with Redis‑based distributed caches and locks—using SETNX, Lua scripts, and Redisson—the article shows Spring Boot developers how to prevent cache breakdown, ensure data consistency, and dramatically improve throughput in high‑concurrency web applications.
This article documents a step‑by‑step performance optimization of a Python web module, covering requirement analysis, environment setup, load‑testing results, database and TCP bottleneck identification, caching strategies, kernel tuning, and the final achievement of 50,000 QPS with low latency.
The article describes the concept, architecture, and Java implementation of a distributed request amplifier in the DCS_FunTester framework that multiplies local QPS to achieve high‑throughput performance testing without affecting the tested service's load.
This article explains the fundamentals of microservices architecture, outlines its core characteristics and key benefits, and discusses why specialized testing strategies—including system‑level and service‑level performance testing—are essential, while recommending several load‑testing tools for effective evaluation.
In a series of local benchmarks on a 2.6 GHz six‑core Intel i7 machine, the author compares K6, Gatling, and FunTester under 10 k to 20 k QPS loads, detailing CPU, memory, and response‑time metrics, analyzing script languages, JVM settings, and offering optimization suggestions for FunTester.
The article analyses a real‑world Node.js service outage caused by sudden 504 timeouts, explains how the asynchronous I/O model creates time‑slice contention under high QPS, presents load‑testing code and results for both I/O‑ and CPU‑bound requests, and offers practical mitigation strategies such as clustering, caching and resource scaling.
This article explains the core concepts of microservices, outlines their key benefits such as rapid delivery and scalability, discusses the need for specialized testing strategies, and reviews popular load‑testing tools to ensure reliable performance in distributed systems.
This article introduces a flexible, script‑driven performance testing approach built on the FunTester framework, explains how to write Groovy/Java test scripts, demonstrates a demo implementation with reflection‑based execution, and covers test case creation, transmission, and execution for HTTP‑based load testing.
This article benchmarks four load‑testing frameworks—JMeter, k6, Locust, and FunTester—across multiple concurrency levels, measuring CPU, memory, QPS and response time to reveal each tool’s strengths, weaknesses, and scalability limits.
A practical comparison of seven open‑source load‑testing frameworks—JMeter, k6, Gatling, Siege, nGrinder, Locust and FunTester—covers language, usage mode, test‑case format, distribution support, usability, extensibility, traffic orchestration, community size and readability, and explains why several tools were ultimately discarded.
This article explains how to combine traffic replay and custom request generation using a segment‑random approach, provides two Java implementations (CPU‑heavy and memory‑heavy), shows test scripts and a full project example, and demonstrates that the generated load matches the configured request distribution.
This article walks through the design and implementation of a Docker‑based distributed performance testing framework using FunTester, detailing the master‑scheduler, slave agents, test case packaging, code examples, and sample results for load‑testing a target service.
This article explains how to assess and design system capacity by analyzing real‑world scenarios—such as a company sports event—calculating required concurrency, average and peak QPS using the 80/20 rule, performing load tests, and determining instance counts to ensure reliable performance under varying traffic spikes.
This tutorial walks you through preparing, installing JMeter and its WebSocket plugin, configuring a WebSocket sampler, and executing a full end‑to‑end test case, including JSON payload handling, result verification, and common pitfalls for reliable backend service testing.
This article describes Dada Group’s evolution from a simple 1:1 test environment to a sophisticated machine‑labeling load‑testing solution, detailing core design, isolation techniques, custom testing platform, model construction, pre‑heat strategies, and post‑test analysis that ensure system stability during high‑traffic events.
This article details Dada Group's full‑link load‑testing architecture, from industry background and machine‑tagging design to platform components, deployment workflow, optimization plans, fine‑grained modeling, pre‑heat strategies, post‑test analysis, and the resulting stability and efficiency gains.
This article introduces the Python‑based Locust load‑testing framework, explains its event‑driven architecture, weight‑based task distribution, command‑line and web UI operation, distributed execution, and practical usage patterns, then evaluates its advantages, drawbacks, and suitability for performance testing projects.
The article explains why a single‑threaded request generator fails at high QPS, introduces a multithreaded generator with a configurable per‑thread QPS limit, provides the full Java implementation, and shows that it reliably sustains 10‑20k QPS in practice.
This article documents a Python web service performance optimization case, detailing the initial bottlenecks, architectural redesign with caching and message queues, load‑testing methodology, Linux TCP time‑wait tuning, and the final results achieving 50k QPS with sub‑70 ms latency.
Facing rising traffic, JD Daojia’s in‑house load‑testing platform was redesigned to automate script management, enable distributed JMeter execution, integrate real‑time monitoring, and support custom RPC protocols, dramatically lowering manual effort, cutting test cycles from an hour to fifteen minutes while ensuring system stability.
This article introduces Locust, an open‑source Python load‑testing framework, explains how to install it (including optional pyzmq for distributed mode), describes its core components, walks through a sample test script with database integration, and shows how to run and interpret results via the web UI or command line.
This article explains the concept of soft‑start in performance testing, presents Java implementations for both fixed‑thread and fixed‑QPS models, discusses error‑impact considerations, and provides practical code snippets to gradually ramp up load and improve measurement accuracy for high‑throughput services.
This article presents a systematic analysis of how thread numbers, request counts, response times, and response‑time variance affect performance‑testing error rates, using a Java demo that simulates single‑API calls and reports detailed JSON metrics for each configuration.
This article introduces Youzan's testing team, detailing its growth to over 120 engineers across three cities, the test‑development responsibilities, automation and load‑testing practices, quality‑assurance framework, training programs, and the open, growth‑focused team culture that candidates can expect.
This article examines the challenges of chain performance testing without branch handling, proposes logical branch controls and synchronized test termination, and provides concrete Java code examples to improve reliability and accuracy of load‑testing pipelines.
This article explains how to enrich a performance‑testing framework with an asynchronous progress bar that also reports real‑time QPS, detailing the design of a unified Progress class, its handling of different thread models, the QPS calculation logic, a sample Groovy test script, and the resulting console output.
This article explains how to extend a performance testing framework to record and visualize individual HTTP interface latencies by parsing consolidated logs, grouping timings by URL, and using a Groovy script with StatisticsUtil to generate response‑time charts.
This article explains what performance testing is, introduces the four core system metrics—response time, throughput, resource utilization, and concurrency—illustrates their relationships, details how request latency is composed, and presents practical tuning techniques and real‑world case studies to improve system performance.
The article details how an online education provider progressively enhanced its live‑streaming performance testing framework—from rudimentary "stone age" checks to automated, data‑driven "information age" practices—by restructuring services, refining test scenarios, introducing traffic replay, and automating script generation to achieve more reliable and efficient stability assurance.
This article walks through the design, scenario planning, and Java implementation of a fixed‑thread load test that simulates teacher login, knowledge‑point queries, course recommendations, and collect/uncollect actions, then presents the resulting performance metrics.
This article introduces the fundamentals of full‑chain load testing, explains why it is essential for large‑scale distributed systems, outlines the DESP model with its four simulation dimensions, and presents a detailed case study of New Oriental's continuation‑class platform including architecture, data preparation, load design, automation and recruitment information.
After mastering the Socket protocol and a fixed‑QPS load‑testing model, I built a comprehensive Socket.IO performance test that simulates a teacher‑student scenario, measures message latency, identifies calculation errors and logging overhead, and reveals several bugs and optimization opportunities in the asynchronous handling and compensation threads.
This article presents a practical demo for multi‑chain performance testing with FunTester, describing the overall workflow, custom multithreaded implementation, Java code example, and sample console output to illustrate how to execute and analyze load tests across multiple request paths.
This article clarifies the distinction between stress testing and load testing, describing their respective models—fixed‑thread and fixed‑QPS—along with key metrics, formulas, and practical benefits for evaluating system performance under varying workloads.
This article details iQIYI's end‑to‑end load‑testing methodology for its payment platform, covering problem identification, core‑link mapping, environment setup, realistic traffic modeling, execution safeguards, results from capacity verification and stress testing, and future plans for a unified testing solution.
This article explains how to use Java's CyclicBarrier and related concurrency utilities to parallelize user login preparation for load testing, reducing setup time and synchronizing multi‑stage performance tests with concrete code examples and sample console output.
This article describes how to implement a multi‑interface performance test for the collect and uncollect operations of a teacher’s resource list, using Groovy scripts, a custom FunTester framework, multithreaded request generation, request‑id tracking, and response recording to produce QPS and RT metrics.
The stability‑assurance squad built an online load‑testing framework that injects global TraceIds via a Java‑agent, records real‑traffic, routes test writes to shadow databases and caches, enforces automatic stop‑rules, and provides a UI platform, reducing cost, improving capacity insight, and enabling safe fault‑injection drills.
