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 article walks through using the FunTester framework to benchmark MySQL insert and delete operations, showing Java code examples, test configurations, and JSON results that reveal a high QPS for inserts and a noticeable slowdown when deletions are performed.
This article explains why traditional CPU usage metrics are unreliable for real‑time audio/video apps, introduces essential performance indicators, reviews native and third‑party analysis tools for iOS and Android, and proposes power‑consumption‑based evaluation methods with practical testing guidelines.
This article describes the evolution from a Node.js‑based WebSocket gateway to a Go‑powered, gRPC‑enabled architecture, detailing the redesign of the gateway, resource‑saving techniques, heartbeat and TLS optimizations, message‑broker choices, extensive performance testing, and the resulting improvements in CPU, memory, and scalability for millions of concurrent connections.
This article details the design and implementation of a Hystrix‑style circuit breaker for PHP, covering circular and fixed bucket counters, distributed time synchronization, dynamic Apollo configuration, event handling, monitoring tools, single‑node versus cluster approaches, key‑length handling, storage abstraction, and performance testing results.
This article explains how to meet a performance‑testing requirement for cancelling orders 10 seconds after placement by leveraging Java's thread‑safe DelayQueue, detailing the design, implementation, test case, execution steps, and observed results.
This article explains how Flink and ClickHouse can be combined to build a real-time data warehouse with end-to-end Exactly-Once guarantees, detailing the underlying write mechanisms, transaction state machine, connector implementation, and performance test results, while also outlining future enhancements for distributed transactions.
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.
This guide explains how to use Redis's built-in redis-benchmark tool to simulate concurrent client load, interpret key performance metrics such as request latency and throughput, and monitor server resource usage, helping operators prevent cache-related failures like penetration and avalanche after deployment.
The article explains the typical live‑streaming architecture, its core modules, the impact of CDN integration, and three major challenges—video‑stream pressure, low‑latency interactive protocols, and high‑concurrency pulse traffic—while showing how Alibaba Cloud PTS can be used for realistic performance testing.
The article explains how adopting automation and continuous testing—through appropriate tools, metric tracking, containerization, transparent communication, multi‑layer and performance testing—accelerates error detection, improves software quality, and enables faster, reliable releases in modern DevOps pipelines.
This guide walks through the end‑to‑end workflow of sending JMeter test metrics to InfluxDB via Backend Listener, storing them alongside node_exporter data in Prometheus, and visualizing TPS, response time, and resource usage in Grafana dashboards, complete with configuration steps and code examples.
iQIYI’s iOS stability testing platform combines a three‑layer cloud device farm architecture with both random monkey and AI‑enhanced element‑traversal event generation, uses screenshot fingerprinting and OCR to mitigate runtime pop‑ups, and achieves roughly 30 % higher page coverage while detecting hundreds of crashes in production.
This step‑by‑step guide introduces beginners to JMeter, covering download, Java setup, creating a thread group, configuring HTTP requests, adding listeners, and running a simple load test to simulate virtual users, enabling you to quickly start performance testing of web applications.
This article walks through a real‑world Java logging slowdown, explains how to benchmark the code with JMH, and shows step‑by‑step usage of Arthas commands like monitor, trace, and watch to pinpoint the exact cause of the performance regression.
This article describes how Ctrip's hotel data platform migrated from ClickHouse to StarRocks, detailing the platform's current state, pain points, the evaluation and selection of StarRocks, its architecture, performance benchmarks, data ingestion models, high‑availability design, and future migration plans.
This article explains how to design and evaluate system capacity—covering concepts like QPS, concurrency, peak‑traffic estimation, stress testing, and practical steps to ensure your services can handle both normal loads and sudden traffic spikes without failure.
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 estimate and plan system capacity—covering concepts like QPS, concurrency, peak traffic calculation, load testing, and practical steps with examples—to ensure services can handle both regular and surge workloads effectively.
This article explains how to assess and design system capacity by translating a real‑world sports event scenario into concrete metrics such as daily visits, average and peak QPS, concurrency, and instance limits, while outlining practical steps, formulas, and a book‑reservation case study.
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 explains how to design and evaluate system capacity by using a sports event example, defining key metrics such as QPS, TPS and concurrency, applying the 80/20 rule, performing stress tests, and calculating required instances for reliable operation.
Learn how to use Redis's built-in redis‑benchmark tool to simulate concurrent clients, configure request parameters, interpret performance metrics, and visualize results, ensuring your Redis deployment is properly tested for throughput, latency, and resource utilization before production.
This article examines how enabling the MTS (writeset‑based incremental parallel replay) feature in DTLE and MySQL affects data transfer speed, CPU and memory usage, and network latency, presenting test procedures, configurations, and performance results that show up to 28‑fold speed improvements.
This article demonstrates how to use the FunTester framework to benchmark Redis hash (map) and INCR commands, detailing the test design, Java code implementation, multithreaded execution, and summarizing the observed performance results.
This article explains Groovy’s default‑parameter feature, shows how to embed scripts and random values in defaults, demonstrates practical API‑testing examples, and compares the execution cost of using default values versus explicit arguments in a high‑iteration performance test.
This article outlines systematic methods for diagnosing subtle performance issues by leveraging detailed data analysis of CPU, memory, disk I/O, and network metrics, and presents real-world case studies that demonstrate how targeted profiling and optimization can reveal and resolve hidden bottlenecks in complex systems.
This article presents a detailed multi‑threaded performance benchmark of Redis list commands using the FunTester framework, describing three test scenarios, Java implementation details, raw JSON results, and observations on QPS and latency for insert, pop, and combined add‑remove operations.
This article presents a curated set of 140 software testing interview questions covering topics such as API testing, automation frameworks, performance testing, CI/CD, database operations, Selenium, mobile testing, and related concepts, offering valuable preparation material for candidates.
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 guide walks you through creating a JMeter thread group, adding HTTP samplers, configuring listeners, using the JSON Extractor to capture response data, and handling multiple variables, enabling you to chain API calls and validate responses efficiently.
This article describes how to design, implement, and evaluate a scalable backend that can simulate 10 billion WeChat red‑envelope requests by supporting up to 1 million concurrent users and handling 30 k–60 k QPS per server using Go, Linux tools, and custom monitoring.
This article walks through a practical performance test for continuously adding key‑value pairs to Redis using the FunTester framework, detailing the test design, Java and Groovy implementations, execution logs, result metrics, and key takeaways for future Redis benchmarking.
This article shares practical experiences and advice on learning software development by copying code, covering where to find source code, official documentation, exemplary implementations, and search engines, and illustrates the approach with real‑world examples from the FunTester testing framework.
This article analyzes common like‑system business scenarios, derives functional requirements, proposes three architectural solutions (Redis‑based priority queue, relational database, and a hybrid cache‑MQ‑DB design), presents detailed implementation code, and evaluates each approach with extensive performance tests to guide practical backend design choices.
The Creation Quality Platform (CQ) automates large‑scale detection of templates, mini‑programs, and special‑effect resources across ByteDance apps, combining automated pipelines, algorithmic classification, CV/NLP checks, and prioritized task routing to boost efficiency, accuracy, and creator experience while reducing manual effort.
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.
The article analyzes the instability of shared‑type virtual machines, introduces enterprise‑level instances with fixed CPU scheduling and NUMA topology, details the applied technologies such as CPU pinning, PCI‑Passthrough and multi‑queue NICs, and presents extensive sysbench and STREAM benchmark results that demonstrate superior isolation, stability and performance of enterprise instances over shared ones.
This article walks through creating a reusable Redis connection‑pool manager and a functional wrapper class in Java, explaining pooling concepts, resource recycling, and providing ready‑to‑use methods for common Redis commands to support efficient performance testing with the FunTester framework.
This case study details how Car Home leveraged TiDB 5.1.1 with a three‑data‑center, five‑replica HTAP architecture to support the high‑traffic 818 Global Auto Festival, covering background, business requirements, database selection, system design, performance challenges, solutions, and post‑event insights.
This article explains QPS and TPS concepts, their differences, how they relate to concurrency, throughput, and key performance metrics such as PV, UV, DAU, and provides practical guidance for evaluating and testing system capacity.
This article explores the practical impact of asynchronous HTTP requests in Java NIO‑based performance testing, detailing server setup with Moco, baseline measurements, various async implementations, and the trade‑offs between raw speed gains and CPU consumption.
This article explains how to modify JMeter's source code so that the JDBC Request sampler returns results in a clean JSON format, covering environment setup, code changes, building the custom JAR, integration, and the resulting improvements in readability and automation.
This article walks through the design, evolution, and technical details of FunTester—a Java/Groovy‑based open‑source testing framework that unifies functional, automated, and performance testing, explains why existing tools like Postman and JMeter fall short, and outlines its distributed testing service and future roadmap.
After a weekend of code refactoring, asynchronous processing, and removing unnecessary statistics, the author increased FunTester's QPS from 104,375 to 118,904 (≈13.9% gain), reduced memory consumption by over 57%, and documented detailed performance impacts of various optimizations with code samples and benchmark tables.
This article explains how to design and evaluate system capacity by defining key concepts such as design capacity, TPS, QPS, and concurrency, outlining when capacity assessment is needed, and providing a step‑by‑step methodology with real‑world examples and calculations for accurate performance planning.
This article examines the challenges faced by a search middle platform—such as inaccurate impact assessment, unstable underlying clusters, and missing process standards—and details a comprehensive quality‑assurance strategy that includes baseline test suites, stability practices, performance testing, emergency drills, and systematic monitoring to ensure reliable search services.
This article examines the architectures, core features, and performance of several open‑source API gateways—including Nginx, Kong, APISIX, Tyk, Zuul, and Gravitee—by deploying sample services with Docker Compose, testing routing, load‑balancing, authentication, and other capabilities, and presenting benchmark results.
This article reviews typical cloud‑native storage options for stateful workloads, analyzes their advantages and drawbacks, discusses the specific needs of OLTP and OLAP databases, outlines challenges in multi‑cloud environments, and presents performance test results of four popular cloud‑native storage systems.
This article details a practical implementation of a distributed performance testing framework using DCS_FunTester, describing the master‑slave architecture, Docker image setup, Groovy/Java scripts, sample code, console output, and server logs to help engineers replicate the approach.
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.
Microservices, as lightweight, independent, and loosely coupled services, offer flexibility, rapid delivery, and scalability, but their distributed nature introduces performance challenges that require distinct testing approaches—both system‑level and service‑level—using advanced load‑testing tools such as InfluxDB, JMeter, CloudWatch, and Grafana.
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.
The article explains the importance of conducting full‑link performance testing in production environments, outlines the evolution of testing stages, details key technologies such as traffic shading and data isolation, offers practical process recommendations, and shares real‑world case studies demonstrating cost savings and risk mitigation.
This article explains how to design and implement a secure gRPC gateway using OpenResty, analyzes performance bottlenecks such as excessive TIME_WAIT connections, and provides practical kernel and Nginx/OpenResty tuning steps to achieve long‑lived connections and lower latency.
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 analyzes the architectures, core features, Docker‑Compose deployments, and k6 performance results of six open‑source API gateways—NGINX, Kong, APISIX, Tyk, Zuul and Gravitee—providing practical guidance for selecting a suitable gateway in microservice environments.
The article reviews four in‑depth talks from MTSC2021 Shanghai, detailing how ZTO, Meituan, ByteDance and Kujiale build large‑scale testing frameworks, event‑tracking QA, advertising system reliability, and multi‑dimensional online inspection to ensure product quality across complex business scenarios.
This article clarifies key performance metrics such as QPS, TPS, PV, UV, DAU, MAU, concurrent users, and system throughput, explains their differences, relationships, and how they impact capacity planning, while also outlining essential performance testing concepts and evaluation methods for robust system design.
This article introduces the FunTester distributed testing framework, explains its single‑node HTTP API, provides complete Java, generic Java, and Groovy code examples, details request parameters, response structure, and the underlying PerformanceResultBean class for analyzing test results.
This article explains how to estimate and design system capacity—including traffic, concurrency, QPS, and resource requirements—by illustrating concepts, analytical formulas, peak‑load assessment techniques, performance testing, and a practical case study of a book‑reservation system.
Jeff Geerling compared the time it takes to compile a Raspberry Pi OS Linux kernel on an Intel i9‑powered MacBook Pro, an M1 Mac mini and an M1 MacBook Air, finding the M1 machines finish up to 30% faster while staying cooler and quieter.
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 explains how to design and implement distributed performance testing cases using jar‑method invocations, demonstrates a Java demo with reflection‑based execution, discusses common pitfalls, and shows how to package, deploy, and run the test cases within a Docker‑enabled environment.
The JD Health Technical Product Team organized a comprehensive 618 promotion preparation in 2021, covering system architecture reviews, capacity assessments, performance stress testing, offensive‑defensive drills, system optimization, 24‑hour monitoring, and product operation training to ensure high availability and stable service during the large‑scale sales event.
This article details how Lakala built a distributed, cloud‑native messaging platform using Apache Pulsar, covering functional requirements, architectural advantages, performance testing, and real‑world integration scenarios such as OGG adapters, TiDB pipelines, OpenMessaging, custom sources, functions, Flink connectors, and future plans.
This article shares three years of experience building an automated performance‑testing platform for Alibaba Cloud Elastic Compute, covering what performance testing is, how to design comprehensive tests for CPU, memory, storage, network and OS, and the essential skills engineers need to become true performance architects.
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.
This article details the billing group's challenges with single‑node MySQL, the evaluation of alternative databases such as TiDB and CockroachDB, performance testing, migration strategies, operational best practices, and the final decision to adopt TiDB for scalable, high‑availability data services.
This article explains the purpose of the TCP TIME_WAIT state, how it prevents packet loss and connection errors, examines its duration based on the Maximum Segment Lifetime, and analyzes why high‑QPS load testing tools like ab may appear to bypass TIME_WAIT, revealing the impact on server resources.
This guide explains how to extend the moco API with request‑hit monitoring, demonstrates building a lightweight test service, and shows achieving over 50,000 QPS using FunTester, while detailing the available assertion methods and their practical code examples.
Over four years at Ele.me, the author chronicles the transformation of the order platform from a single‑machine Python monolith to a distributed, sharded, message‑driven architecture, detailing challenges in scaling, performance testing, fault injection, Redis usage, and service separation that shaped today’s robust backend.
This article explores how to accurately measure QPS in Java performance‑testing scripts by using JsonPath and regular‑expression validation, analyzes error margins under different thread and iteration configurations, and demonstrates that exception handling has minimal impact on overall throughput.
This document outlines a detailed testing strategy for the Cloud Classroom mobile app, covering security, static code analysis, performance, compatibility, and overall quality assurance to ensure stable functionality and a positive user experience.
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 examines how adding Java thread‑safe classes and the synchronized keyword influences QPS in performance testing, presenting code modifications, benchmark results for 20 and 40 threads, and concluding that their impact on measured throughput is minimal.
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.
The article explains that mysqlslap appears to produce smoother latency results than sysbench because mysqlslap reports metrics per test round rather than per individual SQL statement, leading to mis‑interpretation of Max/Avg/Min values, while sysbench can reveal per‑statement latency variations.
This article explains how to work around Groovy's invokeMethod limitation of accepting only a single Object argument by using String arrays or var‑args, demonstrates Java and Groovy reflection implementations, and provides complete code examples for multi‑parameter performance test scripts.
The guide explains YouZan’s low‑code BOS platform, its component‑based architecture, and a multi‑level testing methodology—including automated component, product, and workflow tests, traffic replay, performance checks, and a robust fallback mechanism—to ensure seamless migration and reliable operation of digitized business processes.
This article experimentally examines how different sources of performance‑test error—fixed versus random request latency, thread‑count variations, and log‑printing overhead—affect QPS calculations, revealing that higher concurrency amplifies error while increased request repetitions and reduced logging improve measurement accuracy.
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.
The article chronicles Eleme’s four‑year journey of transforming its order platform—from the early Python‑based Zeus monolith through team formation, service decoupling, sharding, message broadcasting, testing automation, Redis and cache redesign, to virtual product handling and governance—highlighting practical challenges, decisions, and hard‑won engineering insights.
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 explains how to extend a performance testing framework with new QPS and deviation fields, implement accurate QPS calculations for both fixed‑thread and fixed‑QPS models, and prepare the system for quantitative error analysis using detailed Java code examples.
This article demonstrates how a MySQL DBA can use the open‑source analysis_binlog tool to efficiently parse large binlog files, count DML operations, convert binlog to SQL, and perform parallel analysis after setting up a CentOS test environment and running sysbench stress tests.
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.
The article shares a senior developer’s firsthand observations on how architects differ in attitude, technical depth, system‑level responsibilities, and collaboration, offering practical steps and mindset changes needed to transition from senior engineering to a full‑stack architecture role.
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 how to conduct stress testing using JMeter, monitor Java applications with jconsole and jvisualvm, optimize gateway and microservice performance, improve database query speed with indexing, and tune garbage collection by enlarging the Eden space, providing step‑by‑step instructions and results.
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.
This article explains what a prefix (partial) index is in MySQL, why it can reduce index size and improve query speed, outlines suitable scenarios and limitations, and demonstrates performance differences through a series of tests with varying prefix lengths on a large test table.
This article explains how to eliminate the serial‑login bottleneck in multi‑user performance testing by using Java’s CyclicBarrier to synchronize user logins, then runs a two‑step insert‑update scenario with a custom FunTester class, complete with full code examples and result analysis.
This article explains how to transform a Java HttpRequestBase object into an equivalent curl command, enabling rapid request replay across servers and detailed timing analysis, and demonstrates the process with step‑by‑step code examples and a functional test using the FunTester framework.
This article explains practical techniques for generating varied request parameters—such as random numbers, thread‑safe identifiers, random strings, and upstream data extraction—to avoid identical inputs in multi‑call performance tests and improve test reliability.
iQIYI built a Netty‑based WebSocket long‑connection gateway that centralizes session management, uses RocketMQ for cluster‑wide broadcast, provides a simple HTTP push API, scales horizontally to millions of connections, integrates Prometheus/Grafana monitoring, and dramatically cuts development effort for real‑time features such as comments and authentication.
This article presents a systematic experiment that compares four different IntelliJ IDEA memory configurations on a MacBook Pro, measuring IDE startup time, project loading speed, and JVM garbage‑collection metrics with jstat to identify the most efficient setup for large Java monoliths and micro‑service projects.
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.
