This tutorial walks you through why JMeter distributed testing is needed, the essential pre‑checks, detailed configuration of slave and master nodes, how to launch a test across multiple machines, and common pitfalls with practical fixes, enabling you to scale load tests beyond a single host.
This article walks through Apache JMeter’s architecture, explains the role of each component, and details thirty concrete configuration settings—including thread groups, samplers, timers, and processors—plus distributed testing tips and common pitfalls, enabling you to reliably generate million‑user load.
With microservices and cloud‑native workloads, manual performance test case creation consumes most testing time; this article details a four‑step method—traffic profiling, boundary stress injection, data factory integration, and smart script orchestration—to automatically generate realistic JMeter scripts, avoid common pitfalls, and embed performance contracts into CI/CD.
The article explains why traditional UI automation scripts break under high‑load performance testing and presents a deterministic, three‑level self‑healing framework—locator elasticity, timing adaptation, and flexible assertions—implemented with Python + Playwright in a banking transaction system, raising script stability from 41 % to 96.5 % at 5 k TPS.
This article walks through designing and implementing a complete JMeter load‑testing solution for an e‑commerce platform's big‑sale scenario, covering business‑flow mapping, request correlation, multi‑stage stress testing, real‑time monitoring with InfluxDB + Grafana, bottleneck identification, and practical optimization tips.
This article presents a step‑by‑step experiment that uses JMeter to generate 20,000 HTTP calls against a SpringBoot 2.5.4 service, captures detailed GC logs, calculates the heap memory allocated per request, analyses the impact of request payload and logging, and offers practical tuning recommendations.
The article presents a detailed comparison of two performance test data sets—covering throughput, response time, CPU, disk, memory, and network metrics—after optimization, with ChatGPT analyzing each metric and offering scenario‑based recommendations for e‑commerce systems, while also mentioning a test‑automation product demo.
The article shows how ChatGPT examines JMeter load‑test results, identifies CPU, database and I/O bottlenecks, and then proposes concrete optimizations such as adding indexes, tuning HikariCP pool settings, caching, code refactoring, and monitoring to improve login throughput and latency.
This article breaks down performance testing into three essential dimensions—time behavior, resource utilization, and capacity—explains their key metrics, demonstrates a detailed e‑commerce flash‑sale case study, and shows how systematic testing and optimization can dramatically improve response times, throughput, and scalability.
This article walks through creating performance‑test data with Excel and a Python script, troubleshooting cookie handling issues in Java web applications, and building a complete JMeter test plan—including thread groups, CSV data sets, and assertions—to validate an e‑business login flow.
Load testing, a performance testing technique that simulates massive concurrent users, evaluates throughput, response time, and stability, follows a five‑step workflow—from requirement breakdown to analysis—and helps uncover bottlenecks such as database connection limits or CDN misconfigurations before production launch.
This guide explains how to determine the heap memory consumption of individual HTTP and RPC calls in a SpringBoot application by setting up a JMeter load test, enabling detailed GC logging, and analyzing the results to optimize JVM parameters and improve performance.
This article explains how to measure the exact heap memory consumption of individual SpringBoot HTTP and RPC requests by calculating required memory from request size, configuring JVM GC parameters, creating a JMeter test plan, collecting GC logs, and analyzing results to identify optimization opportunities.
This article measures the heap memory allocated by a single SpringBoot HTTP and RPC request using JMeter load testing and detailed GC logs, revealing that even tiny payloads can consume around 34 KB of heap, and discusses how request size, logging, and JVM settings affect memory usage and GC frequency.
AI can streamline every stage of JMeter performance testing—from automatically drafting test plans and generating JMX scripts to real‑time log analysis, adaptive load control, and automated result interpretation and reporting—while emphasizing the need for engineer verification, data confidentiality, and handling of AI’s context limits.
This article shows how AI can help write Groovy JSR223 scripts that dynamically generate large‑scale, unique, or realistically distributed test data inside JMeter threads, eliminating CSV I/O bottlenecks and improving maintainability for performance testing.
This article walks through using AI to streamline every stage of JMeter performance testing—from automatically generating test plans and JMX scripts, creating realistic parameter data, and writing BeanShell/Groovy logic, to real‑time log analysis, adaptive load control, automated root‑cause analysis, and professional report generation—while highlighting verification, confidentiality, and context‑size considerations.
This article demonstrates how Spring Boot 3.2.5 leverages JDK 21 virtual threads to improve asynchronous request handling, comparing platform‑thread and virtual‑thread performance with JMeter, exploring thread‑pool configurations, database access tests, and providing practical code examples and tuning tips.
This article shows how a senior architect measured the exact heap memory allocated by individual HTTP and RPC requests in a SpringBoot 2.5.4 application using JMeter load testing and detailed GC logs, revealing that a minimal HTTP call consumes about 34 KB while an RPC call can use up to 1 MB, and discusses the performance implications of payload size and logging.
This article explains how to perform HTTP load testing using Postman, Apache Bench, JMeter, and Java concurrency classes such as CountDownLatch and Semaphore, providing step‑by‑step setup, configuration, and code examples for simulating high‑traffic scenarios.
This article details a step‑by‑step experiment using SpringBoot 2.5.4 and JMeter to quantify how much heap memory a single HTTP or RPC request consumes, analyzes GC logs, presents code snippets for the test endpoints, and discusses the impact of logging and payload size on memory usage.
This article details Huolala's performance testing platform architecture, covering background challenges, a JMeter‑based solution, distributed agent design, unified logging, plugin management, data collection via Kafka, and future enhancements such as AI integration and improved file distribution, illustrating a comprehensive backend development effort.
This article provides a comprehensive overview of performance testing fundamentals, covering key concepts, common test types, popular tools, test design strategies, defect management, special‑scenario testing, advanced topics like APM and micro‑services, best practices, and future trends in the field.
This guide walks you through using JMeter's CSV Data Set Config, built‑in functions, JDBC driver setup, and response assertions to perform multi‑data load testing, validate database queries, and enhance test coverage and accuracy.
This article explains the core concept of interface correlation in JMeter and provides a detailed, step-by-step procedure—including test plan creation, HTTP request setup, response extraction, variable sharing, assertions, and listeners—along with an example of passing a login token to subsequent requests and key best‑practice tips.
This article describes an experiment using SpringBoot 2.5.4 and JMeter to measure the heap memory allocated per HTTP and RPC request, detailing the setup, GC logging configuration, results showing average memory consumption around 34 KB per request, and recommendations for logging and performance optimization.
The article reviews Elasticsearch performance testing options—including the official Rally benchmark suite, third‑party solutions such as Logz.io and JMeter, and the open‑source INFINI Loadgen—detailing their automation, version handling, metric reporting, sample benchmark results, and guidance on selecting the right tool for specific workloads.
This article analyzes a high‑concurrency flash‑sale scenario using SpringBoot, MySQL, and JMeter, demonstrates seven implementations—from service‑level locks to AOP, pessimistic/optimistic locks, and queue‑based designs—examines their trade‑offs with concrete code, test results, and practical recommendations.
This article demonstrates how to simulate a high‑concurrency flash‑sale scenario using SpringBoot, MySQL, Mybatis‑Plus and JMeter, analyzes the overselling problem caused by premature lock release, and presents seven solutions—including lock‑first strategies, AOP, pessimistic and optimistic locks, and queue‑based approaches—along with code samples and test results.
This article demonstrates how to experimentally determine the heap memory allocated by individual HTTP and RPC requests in a SpringBoot application using JMeter load testing, GC logging, and code analysis, providing insights into memory consumption, GC frequency, and optimization strategies for backend performance.
The author recounts a four‑year journey from UI automation to Java‑based performance testing, illustrating how mastering Java’s concurrency utilities and Groovy scripting can replace traditional tools like JMeter, enabling flexible, high‑throughput test scenarios and deeper control over test case design.
The article details a SpringBoot experiment that uses JMeter to send 20,000 HTTP requests, captures detailed GC logs, and demonstrates that each request consumes roughly 34 KB of heap memory, with larger payloads and logging increasing the usage, highlighting the importance of memory‑aware coding and log management.
This article explains what QPS (Queries Per Second) is, presents formulas and examples for calculating overall and per‑interface QPS, and shows how to use JMeter to create a test plan, add thread groups and listeners for accurate performance measurement.
This article demonstrates how to quantify the heap memory allocated by individual HTTP and RPC calls in a SpringBoot application by creating a test service, configuring JMeter for load, capturing detailed GC logs, and analyzing the results to guide JVM and logging optimizations.
This article provides a step‑by‑step tutorial on installing, configuring, and using Apache JMeter for load and performance testing, covering test plan creation, thread group settings, HTTP request configuration, listeners, and execution of stress tests, along with download instructions.
This article compares JMeter and Python for interface automation testing, highlighting JMeter's ease of use for beginners versus Python's flexibility for advanced customization, with a detailed learning plan for Python.
This article explains how to leverage smart-doc to automatically generate JMeter performance testing scripts from API code, import them into JMeter, set up Prometheus monitoring and Grafana dashboards, and highlights the automation benefits for backend development and operations workflows.
This article explains how to use BeanShell within Apache JMeter to create custom pre‑processor, post‑processor, and sampler scripts for complex e‑commerce testing, detailing step‑by‑step procedures and providing multiple practical code examples such as extracting JSON fields, generating order IDs, and managing authentication tokens.
This guide explains how to use Docker containers to create a JMeter master‑slave distributed testing environment, covering required ports, Dockerfile configurations for base, master, and slave images, container deployment commands, and running tests both locally and across multiple Dockerized JMeter slaves.
This article demonstrates how to integrate Project Loom virtual threads into a Spring Boot application, configure Maven and Tomcat, implement REST endpoints, run JMeter load tests, and compare response times between traditional and virtual threads to showcase significant performance improvements.
This guide walks you through using Alibaba Cloud PTS and JMeter 5.5 to create a custom JavaSampler for RocketMQ 5.0, package the sampler into a JAR, configure a PTS JMeter environment, run an RPS‑mode load test, and analyze the detailed performance report.
This guide explains MySQL's lock mechanisms—including shared and exclusive locks, row‑level locking requirements, pessimistic versus optimistic strategies, and practical implementations with InnoDB, transaction handling, and JMeter concurrency testing—to prevent overselling in high‑traffic scenarios.
This article demonstrates how to simulate a high‑concurrency flash‑sale scenario using SpringBoot, MySQL and JMeter, analyzes why naive lock‑and‑transaction code causes overselling, and presents six refined solutions—including controller‑level locking, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches—along with performance test results.
This article explains why website performance directly impacts business goals, outlines a four‑scenario testing framework (baseline, capacity, stability, and exception), and provides practical steps for environment setup, data preparation, parameterization, and execution using JMeter.
This guide explains the fundamentals of automation testing, identifies suitable projects, compares common automation types such as web, mobile, and API testing, introduces essential tools like Selenium, Appium, uiautomator2, and JMeter, and provides step‑by‑step code examples to help beginners quickly implement automated tests in real‑world scenarios.
This article introduces the concept and necessity of automated API testing, outlines typical usage scenarios, and provides a detailed comparison of four popular frameworks—Postman + Newman, JMeter + Ant, HttpRunner + Request, and pytest + Request—covering their features, advantages, drawbacks, requirements, and integration steps.
This article describes how a bank’s IT team transformed its performance testing by defining intelligent platform capabilities, designing a modular architecture, and implementing features such as automated risk identification, smart test case generation, data synthesis, multi‑protocol support, chaos injection, and automated result analysis using JMeter, Prometheus, and custom plugins.
This guide explains how to install JMeter on Windows, configure GUI, distributed, and CLI modes, adjust Java and JMeter properties, run load tests, view results, and clean up, providing step‑by‑step instructions and command‑line examples for effective performance testing.
This article details a comprehensive performance testing workflow—including requirement analysis, script recording with BlazeMeter, data construction, iterative optimization, and final results—targeting a web application that must handle over 5,000 TPS with 2 million database records, highlighting bottlenecks in Redis, MySQL, and code logic.
This step‑by‑step guide introduces JMeter, explains how to download and install it (including Java setup), walks through creating a simple test plan with thread groups, HTTP samplers, and listeners, and shows how to run and analyze results, enabling beginners to quickly start performance testing.
This article walks through the evolution of a system’s performance concerns, defines speed and pressure dimensions, explains how to calculate RT, QPS and concurrency, compares QPS with TPS, and provides step‑by‑step methods using tools like Arthas, JMeter and JVM diagnostics to identify and fix CPU, memory and pressure issues before applying layered optimization strategies.
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.
The article explains the purpose and importance of single‑interface load testing for backend APIs, outlines external factors that affect results, recommends appropriate concurrency levels, compares popular tools such as JMeter, ab, and Apipost, and details a step‑by‑step testing workflow with screenshots.
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.
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 article analyzes the overselling problem in high‑concurrency flash‑sale scenarios, demonstrates seven concrete solutions—including improved locks, AOP locks, pessimistic and optimistic database locks, and queue‑based approaches using BlockingQueue and Disruptor—provides full SpringBoot code, JMeter test results, and practical recommendations for reliable stock reduction.
This article analyzes why simple @Transactional and lock annotations still cause overselling in flash‑sale scenarios, then presents seven backend solutions—including improved controller locking, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches with BlockingQueue and Disruptor—along with code samples and JMeter test results.
This article provides a concise overview of ten popular free and open‑source test automation frameworks—including Katalon Studio, Selenium, Appium, JMeter, SOAP UI, Robot Framework, Watir, JUnit, Robotium, and Citrus—highlighting their supported languages, platforms, key features, and integration capabilities.
This guide explains how to build a real‑time monitoring system for JMeter performance tests by integrating InfluxDB, Prometheus, and Grafana, deploying the stack with Docker‑Compose, and configuring JMeter’s Backend Listener to collect and visualize metrics continuously.
This tutorial explains how to use the open‑source MQTT broker EMQX together with Apache JMeter to create, configure, and run performance tests for IoT platforms, covering installation, test plan creation, and result analysis.
This document outlines the background, objectives, scenarios, strategies, TPS estimations, metric definitions, step‑by‑step testing process, component selection, script examples, various execution modes (GUI, CLI, distributed, Docker), and the monitoring architecture built with JMeter, InfluxDB, Prometheus, and Grafana for a large‑scale long‑connection service.
Amid the current tech hiring slowdown, this guide outlines a comprehensive learning roadmap for software testers, covering fundamentals, Linux, shell scripting, web fundamentals, databases, packet‑capture tools, API testing, automation frameworks, mobile testing, TestOps, and performance and security testing to help engineers stay competitive and advance their careers.
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.
This article walks through setting up real‑time performance monitoring by sending JMeter metrics to InfluxDB via Backend Listener, visualizing them in Grafana, and extending the approach to system metrics with node_exporter, Prometheus, and Grafana, covering configuration steps, code snippets, and query examples.
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 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 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 tutorial walks through the end‑to‑end setup of JMeter performance testing data collection using Backend Listener, sending metrics to InfluxDB, and visualizing real‑time TPS, response time, and error rates in Grafana, as well as monitoring OS metrics with node_exporter, Prometheus, and Grafana.
This article walks through the most common performance‑monitoring stack—JMeter, node_exporter, Prometheus, InfluxDB, and Grafana—explaining how to configure backend listeners, send metrics, store them, and build real‑time dashboards while highlighting code snippets and query examples.
This article explains what HTTP redirects are, why they are used, and how they affect everyday API testing with tools like JMeter and Python's requests library, providing practical examples and guidance on handling redirect behavior.
This article compiles a comprehensive list of Groovy-related tutorials and articles covering Java‑Groovy integration, scripting, Gradle builds, JMeter extensions, operator overloading, closures, reflection, and other advanced language features for developers seeking practical guidance.
The article details the architecture, key components, testing types, and operational results of Autohome's PTS platform, which uses Docker Swarm, gRPC, JMeter, Flume‑Kafka, and Flink to conduct large‑scale distributed load testing for the 818 event and outlines future improvements toward Kubernetes and direct Kafka logging.
This article explains what JMeter test fragments are, their application scenarios, how to create and configure them, use module controllers to invoke fragments, and run the test plan to see combined script execution, providing a practical guide for complex performance testing projects.
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 explains how to set up end‑to‑end performance monitoring by sending JMeter metrics to InfluxDB via Backend Listener, visualizing them in Grafana, and similarly collecting system metrics with node_exporter and Prometheus, covering configuration, data storage, query examples, and practical visualization techniques.
This article explains step‑by‑step how to collect JMeter test metrics via Backend Listener, store them in InfluxDB, and display real‑time performance charts—including TPS, response time, and error rates—in Grafana, while also covering node_exporter integration with Prometheus for system‑level monitoring.
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.
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 guide explains step‑by‑step how to configure JMeter’s Backend Listener to send metrics to InfluxDB, set up Prometheus and node_exporter, and create Grafana dashboards for real‑time TPS, response time, and system resource monitoring.
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.
The post reviews an older JMeter Chinese manual, highlighting its surprisingly still‑relevant Java and JMeter fundamentals, describing its 50‑page structure, and providing a comprehensive table of contents covering installation, test plan creation, and various protocol testing modules.
This tutorial walks through the end‑to‑end monitoring pipeline—from JMeter’s Backend Listener sending metrics to InfluxDB, through storing and querying those metrics, to configuring Grafana dashboards for real‑time performance visualization, and also covers OS monitoring with node_exporter, Prometheus, and Grafana.
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 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 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.
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 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 tutorial explains how to download the Moco‑runner JAR, configure various mock scenarios—including GET, POST, parameterized requests, cookies, headers, and redirects—and run them from the command line or through JMeter for comprehensive API testing.
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 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.
As more companies adopt DevOps for faster feedback, this article compares five widely used API testing tools—Rest‑Assured, Postman, SoapUI, JMeter, and Fiddler—highlighting their strengths, ideal team compositions, and integration capabilities to help you choose the most suitable solution.
This article explains how to reproduce a slow‑response SpringBoot service using JMeter, then quickly locate the bottleneck in production by leveraging Alibaba's open‑source Arthas tool and its trace command to analyze the full call chain.
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.
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 guide explains how to create a globally unique, auto‑incrementing variable in JMeter by using a synchronized Groovy script that leverages the built‑in props object, demonstrates setting an initial value, and compares locked versus unlocked execution results.
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 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.
