BestHub
Sign in
Tagged articles
322 articles
Page 2 of 4
php Courses
php Courses
Mar 17, 2023 · Operations

RunnerGo: An Open‑Source Full‑Stack Testing Platform – Features, Architecture, and Quick‑Start Guide

RunnerGo is an Apache‑2.0 licensed full‑stack testing platform built with Go and React that provides API testing, scenario automation, performance testing, and rich reporting, and the article details its features, technology stack, architecture, installation steps, configuration files, and open‑source repositories.

dockerload-testingopen-source
0 likes · 7 min read
RunnerGo: An Open‑Source Full‑Stack Testing Platform – Features, Architecture, and Quick‑Start Guide
HomeTech
HomeTech
Feb 22, 2023 · Operations

Design and Implementation of a Realistic Simulation Load‑Testing System for High‑Concurrency Scenarios

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.

GoLocustSimulation
0 likes · 8 min read
Design and Implementation of a Realistic Simulation Load‑Testing System for High‑Concurrency Scenarios
Advanced AI Application Practice
Advanced AI Application Practice
Feb 20, 2023 · Operations

Three Key Pressure‑Testing Questions: Defining Test Points, Getting Expected Metrics, and Crafting 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.

JMeterScenario TestingTest Strategy
0 likes · 4 min read
Three Key Pressure‑Testing Questions: Defining Test Points, Getting Expected Metrics, and Crafting Strategies
FunTester
FunTester
Feb 12, 2023 · Operations

Using goreplay (gor) for Traffic Capture and Replay in Performance Testing

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.

GoGoReplayHTTP capture
0 likes · 6 min read
Using goreplay (gor) for Traffic Capture and Replay in Performance Testing
FunTester
FunTester
Feb 10, 2023 · Operations

Performance Testing Overview and Tool Recommendations in Continuous 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.

DevOpsJMeterLocust
0 likes · 9 min read
Performance Testing Overview and Tool Recommendations in Continuous Testing
Tencent Cloud Developer
Tencent Cloud Developer
Feb 3, 2023 · Cloud Computing

Cloud Load Testing: Strategies, Scenarios, and Practice Cases for High‑Traffic Events

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.

JavaScriptObservabilitycloud testing
0 likes · 23 min read
Cloud Load Testing: Strategies, Scenarios, and Practice Cases for High‑Traffic Events
FunTester
FunTester
Nov 27, 2022 · Fundamentals

Why Performance Testing Matters: Key Metrics, Types, and Best Practices

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.

Best PracticesMetricsload-testing
0 likes · 10 min read
Why Performance Testing Matters: Key Metrics, Types, and Best Practices
Cloud Native Technology Community
Cloud Native Technology Community
Nov 9, 2022 · Cloud Native

How Sidecars Are Revolutionizing Load Testing in Kubernetes

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.

Cloud NativeDevOpsKubernetes
0 likes · 8 min read
How Sidecars Are Revolutionizing Load Testing in Kubernetes
DeWu Technology
DeWu Technology
Sep 7, 2022 · Operations

DeWu Full-Chain Load Testing Platform: Design and Implementation

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.

JMeterload-testingmonitoring
0 likes · 9 min read
DeWu Full-Chain Load Testing Platform: Design and Implementation
JavaEdge
JavaEdge
Sep 5, 2022 · Operations

Engineering Double‑11‑Scale E‑Commerce Events: A Complete Technical Playbook

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.

Incident ResponseRate LimitingTraffic Engineering
0 likes · 12 min read
Engineering Double‑11‑Scale E‑Commerce Events: A Complete Technical Playbook
Snowball Engineer Team
Snowball Engineer Team
Aug 1, 2022 · Fundamentals

Performance Testing: Concepts, Scenarios, Tools, and Best Practices

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.

JMeterLocustload-testing
0 likes · 27 min read
Performance Testing: Concepts, Scenarios, Tools, and Best Practices
ITPUB
ITPUB
Jul 31, 2022 · Operations

How Bilibili Scaled Live Gift Revenue with Full‑Link Automated Load Testing

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.

Bilibilifull‑linkload-testing
0 likes · 16 min read
How Bilibili Scaled Live Gift Revenue with Full‑Link Automated Load Testing
High Availability Architecture
High Availability Architecture
Jul 19, 2022 · Backend Development

Online Traffic‑Based Functional and Performance Verification System for Order Processing

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.

Backend Architecturefunctional testingload-testing
0 likes · 10 min read
Online Traffic‑Based Functional and Performance Verification System for Order Processing
FunTester
FunTester
Jul 5, 2022 · Backend Development

How to Benchmark gRPC Blocking Stubs in Java: Four Test Models Explained

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.

Blocking StubJavagRPC
0 likes · 10 min read
How to Benchmark gRPC Blocking Stubs in Java: Four Test Models Explained
Bilibili Tech
Bilibili Tech
Jun 24, 2022 · Cloud Native

Evolution and Design of Bilibili's Load‑Testing Platform (Platform 2.0)

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.

Distributed Systemscloud-nativeload-testing
0 likes · 27 min read
Evolution and Design of Bilibili's Load‑Testing Platform (Platform 2.0)
FunTester
FunTester
Jun 24, 2022 · Operations

Performance Testing Resource Collection

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.

Benchmarkingload-testingperformance testing
0 likes · 6 min read
Performance Testing Resource Collection
dbaplus Community
dbaplus Community
Jun 15, 2022 · Operations

How Havok Enables Realistic Full‑Link Load Testing for Scalable Services

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.

Circuit BreakerData Isolationfull‑link testing
0 likes · 14 min read
How Havok Enables Realistic Full‑Link Load Testing for Scalable Services
The Dominant Programmer
The Dominant Programmer
Jun 15, 2022 · Operations

How to Simulate 20,000 Local Requests with JMeter

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.

ConcurrencyHTTP requestJMeter
0 likes · 3 min read
How to Simulate 20,000 Local Requests with JMeter
Java High-Performance Architecture
Java High-Performance Architecture
Jun 14, 2022 · Backend Development

How WeChat Handled 100 Billion Red Packet Requests During the Spring Festival Gala

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.

Backend Architecturehigh concurrencyload-testing
0 likes · 18 min read
How WeChat Handled 100 Billion Red Packet Requests During the Spring Festival Gala
政采云技术
政采云技术
Jun 14, 2022 · Backend Development

Performance Testing, Response Time Analysis, and Database Connection Pool Optimization for a Multi‑Table Query Service

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.

Database Connection PoolDruidMyBatis
0 likes · 12 min read
Performance Testing, Response Time Analysis, and Database Connection Pool Optimization for a Multi‑Table Query Service
Alibaba Cloud Native
Alibaba Cloud Native
Jun 9, 2022 · Operations

Mastering Load Testing: Types, Tools, and Real‑World Case Studies

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.

JMeterapachebenchload-testing
0 likes · 26 min read
Mastering Load Testing: Types, Tools, and Real‑World Case Studies
JavaEdge
JavaEdge
Jun 3, 2022 · Operations

How to Scale Systems: From Load Metrics to Architecture Strategies

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.

LatencyScalabilityarchitecture
0 likes · 15 min read
How to Scale Systems: From Load Metrics to Architecture Strategies
SQB Blog
SQB Blog
May 9, 2022 · Operations

How Havok Enables Realistic Full‑Link Load Testing for Scalable Services

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.

capacity planningfull‑link testingload-testing
0 likes · 16 min read
How Havok Enables Realistic Full‑Link Load Testing for Scalable Services
AntTech
AntTech
Apr 29, 2022 · Operations

Alipay Double‑11 System Stability Practices: Distributed Architecture, Elastic Scaling, Service Mesh, Full‑Chain Load Testing, Intelligent Monitoring, and OceanBase

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.

Cloud NativeOceanBasedistributed architecture
0 likes · 11 min read
Alipay Double‑11 System Stability Practices: Distributed Architecture, Elastic Scaling, Service Mesh, Full‑Chain Load Testing, Intelligent Monitoring, and OceanBase
Alibaba Cloud Native
Alibaba Cloud Native
Apr 22, 2022 · Operations

How to Design and Execute Performance Tests for Mini‑Programs with PTS

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.

Mini ProgramPTSPerformance tuning
0 likes · 9 min read
How to Design and Execute Performance Tests for Mini‑Programs with PTS
IT Services Circle
IT Services Circle
Apr 5, 2022 · Backend Development

Building High-Concurrency Skills: A Candidate’s Journey and Practical Guidance

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.

Performance Optimizationhigh concurrencyload-testing
0 likes · 10 min read
Building High-Concurrency Skills: A Candidate’s Journey and Practical Guidance
IT Architects Alliance
IT Architects Alliance
Mar 27, 2022 · Backend Development

Simulating a 10‑Billion Red‑Envelope System with Go: From 3K to 6K QPS

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.

Distributed SystemsGobackend
0 likes · 21 min read
Simulating a 10‑Billion Red‑Envelope System with Go: From 3K to 6K QPS
Java High-Performance Architecture
Java High-Performance Architecture
Mar 16, 2022 · Operations

Why Every Line of Code Matters: Lessons from Boosting Web App Performance 3000×

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.

Performance OptimizationSREdatabase connections
0 likes · 9 min read
Why Every Line of Code Matters: Lessons from Boosting Web App Performance 3000×
FunTester
FunTester
Feb 27, 2022 · Operations

Performance Testing Articles Collection (Chinese Resources)

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.

BenchmarkingOperationsload-testing
0 likes · 8 min read
Performance Testing Articles Collection (Chinese Resources)
Selected Java Interview Questions
Selected Java Interview Questions
Feb 25, 2022 · Operations

How Every Line of Code Impacts Performance: Lessons from Optimizing Legacy Web Applications

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.

SREdatabase connectionslegacy systems
0 likes · 9 min read
How Every Line of Code Impacts Performance: Lessons from Optimizing Legacy Web Applications
IT Architects Alliance
IT Architects Alliance
Feb 15, 2022 · Operations

What Real-World Performance Tuning Taught Us About Legacy Web Apps

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.

APMOperationsSRE
0 likes · 9 min read
What Real-World Performance Tuning Taught Us About Legacy Web Apps
Top Architect
Top Architect
Feb 13, 2022 · Operations

Performance Optimization Lessons from a Legacy Web Application: Monitoring, Load Testing, and Maintaining Old Systems

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.

SREbackendlegacy systems
0 likes · 9 min read
Performance Optimization Lessons from a Legacy Web Application: Monitoring, Load Testing, and Maintaining Old Systems
IT Architects Alliance
IT Architects Alliance
Feb 9, 2022 · Backend Development

How to Build a 10‑Billion‑Request Red‑Envelope System: Design, Implementation, and Lessons Learned

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.

Distributed SystemsGolangbackend
0 likes · 20 min read
How to Build a 10‑Billion‑Request Red‑Envelope System: Design, Implementation, and Lessons Learned
21CTO
21CTO
Feb 7, 2022 · Operations

Why Every Line of Code Matters: Boosting Performance by 3000% with a Simple DB Fix

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.

APMOperationsPerformance Optimization
0 likes · 9 min read
Why Every Line of Code Matters: Boosting Performance by 3000% with a Simple DB Fix
NetEase LeiHuo Testing Center
NetEase LeiHuo Testing Center
Jan 21, 2022 · Operations

Game Stress Testing: Types, Metrics, and Robot Tools

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.

AutomationGame performanceServer
0 likes · 9 min read
Game Stress Testing: Types, Metrics, and Robot Tools
FunTester
FunTester
Dec 31, 2021 · Operations

FunTester’s 2021 Leap: 100k+ QPS Performance & Distributed Testing Insights

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.

Distributed SystemsGoJava
0 likes · 10 min read
FunTester’s 2021 Leap: 100k+ QPS Performance & Distributed Testing Insights
Top Architect
Top Architect
Dec 17, 2021 · Operations

API Load Testing with Postman, ApacheBench, JMeter, and Java Concurrency

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.

JMeterJava concurrencyPostman
0 likes · 10 min read
API Load Testing with Postman, ApacheBench, JMeter, and Java Concurrency
Programmer DD
Programmer DD
Dec 17, 2021 · Backend Development

Mastering API Load Testing: Postman, ApacheBench, JMeter & Java Concurrency

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.

API testingJMeterJava concurrency
0 likes · 8 min read
Mastering API Load Testing: Postman, ApacheBench, JMeter & Java Concurrency
Efficient Ops
Efficient Ops
Dec 5, 2021 · Backend Development

How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning Steps

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.

LinuxPerformance OptimizationPython
0 likes · 9 min read
How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning Steps
Open Source Linux
Open Source Linux
Nov 30, 2021 · Operations

Essential Sysadmin Toolkit: LDAP, Automation, DNS, Load Testing & Security

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.

DNSLDAPSecurity
0 likes · 7 min read
Essential Sysadmin Toolkit: LDAP, Automation, DNS, Load Testing & Security
FunTester
FunTester
Nov 18, 2021 · Backend Development

Dynamic Load Adjustment in FunTester: A Step‑by‑Step Implementation Guide

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.

Dynamic ScalingFunTesterJava
0 likes · 12 min read
Dynamic Load Adjustment in FunTester: A Step‑by‑Step Implementation Guide
DeWu Technology
DeWu Technology
Nov 16, 2021 · Databases

Full-Chain Load Testing: Redis Large-Key and Memory Leak Issues and Solutions

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.

Memory LeakRedisbackend
0 likes · 7 min read
Full-Chain Load Testing: Redis Large-Key and Memory Leak Issues and Solutions
Zhongtong Tech
Zhongtong Tech
Oct 19, 2021 · Operations

Transforming Load Testing at ZTO: From Offline Pitfalls to Safe Full‑Chain Online Testing

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.

Operationsfull-chain testingload-testing
0 likes · 17 min read
Transforming Load Testing at ZTO: From Offline Pitfalls to Safe Full‑Chain Online Testing
FunTester
FunTester
Oct 14, 2021 · Backend Development

How to Model and Simulate API Traffic for Precise Load 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.

API testingBackend DevelopmentJava
0 likes · 6 min read
How to Model and Simulate API Traffic for Precise Load Testing
FunTester
FunTester
Oct 13, 2021 · Operations

Dynamic Load Adjustment in FunTester: A Real‑World Pressure‑Control Demo

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.

FunTesterJava concurrencyPhaser
0 likes · 15 min read
Dynamic Load Adjustment in FunTester: A Real‑World Pressure‑Control Demo
Selected Java Interview Questions
Selected Java Interview Questions
Sep 21, 2021 · Backend Development

Performance Optimization of a High‑Concurrency Web Service: From Bottleneck Identification to TCP Time‑Wait Tuning

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.

CachingTCPload-testing
0 likes · 8 min read
Performance Optimization of a High‑Concurrency Web Service: From Bottleneck Identification to TCP Time‑Wait Tuning
JD Tech
JD Tech
Sep 3, 2021 · Operations

High-Fidelity Load Testing: Practices and Technical Innovations from JD's ForceBot Platform

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.

Distributed SystemsJD ForceBothigh-fidelity testing
0 likes · 8 min read
High-Fidelity Load Testing: Practices and Technical Innovations from JD's ForceBot Platform
MaGe Linux Operations
MaGe Linux Operations
Aug 24, 2021 · Backend Development

How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning Guide

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.

Linux TuningPerformance Optimizationload-testing
0 likes · 8 min read
How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning Guide
FunTester
FunTester
Aug 20, 2021 · Backend Development

Building a Distributed Load‑Testing Framework: Gradle Multi‑Module & Maven Tips

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.

Distributed TestingFrameworkGradle
0 likes · 8 min read
Building a Distributed Load‑Testing Framework: Gradle Multi‑Module & Maven Tips
TAL Education Technology
TAL Education Technology
Aug 19, 2021 · Operations

Comprehensive SRE Guide for Summer and Winter High‑Load Periods in an Online Education Platform

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.

Incident ManagementSREcapacity planning
0 likes · 17 min read
Comprehensive SRE Guide for Summer and Winter High‑Load Periods in an Online Education Platform
Java Tech Enthusiast
Java Tech Enthusiast
Aug 7, 2021 · Backend Development

Cache Optimization and Distributed Locking in High-Concurrency Systems

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.

Cache ConsistencyCachingDistributed Systems
0 likes · 16 min read
Cache Optimization and Distributed Locking in High-Concurrency Systems
Efficient Ops
Efficient Ops
Aug 4, 2021 · Backend Development

How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning

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.

Performance OptimizationPythonRedis
0 likes · 9 min read
How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning
FunTester
FunTester
Jul 30, 2021 · Operations

Distributed QPS Amplifier Design in DCS_FunTester Framework

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.

Javadistributed systemload-testing
0 likes · 6 min read
Distributed QPS Amplifier Design in DCS_FunTester Framework
Top Architect
Top Architect
Jul 6, 2021 · Backend Development

Microservices Architecture: Core Features, Advantages, and Performance Testing Strategies

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.

DevOpsarchitecturedistributed-systems
0 likes · 8 min read
Microservices Architecture: Core Features, Advantages, and Performance Testing Strategies
FunTester
FunTester
Jul 5, 2021 · Industry Insights

Which Load Testing Tool Wins at 100k QPS? K6 vs Gatling vs FunTester Benchmarks

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.

FunTesterGatlingJVM
0 likes · 11 min read
Which Load Testing Tool Wins at 100k QPS? K6 vs Gatling vs FunTester Benchmarks
Beike Product & Technology
Beike Product & Technology
Jul 1, 2021 · Backend Development

Understanding Node.js Asynchronous I/O Model and Its Impact on High‑Concurrency Performance

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.

CPU BottleneckNode.jsasynchronous I/O
0 likes · 20 min read
Understanding Node.js Asynchronous I/O Model and Its Impact on High‑Concurrency Performance
FunTester
FunTester
Jun 30, 2021 · Operations

Script‑Based Performance Testing Scenarios Using the FunTester Framework

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.

FunTesterGroovyJava
0 likes · 13 min read
Script‑Based Performance Testing Scenarios Using the FunTester Framework
FunTester
FunTester
Jun 25, 2021 · Industry Insights

Load Testing Showdown: JMeter, k6, Gatling, Siege, nGrinder, Locust & More

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.

JMeterload-testingopen-source tools
0 likes · 7 min read
Load Testing Showdown: JMeter, k6, Gatling, Siege, nGrinder, Locust & More
FunTester
FunTester
Jun 21, 2021 · Operations

How to Simulate Realistic Traffic with Segment Randomization in Java Performance Tests

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.

JavaMethodologyload-testing
0 likes · 11 min read
How to Simulate Realistic Traffic with Segment Randomization in Java Performance Tests
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 16, 2021 · Operations

Designing System Capacity: From Event Scenarios to Precise QPS Planning

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.

ConcurrencyQPSSystem Design
0 likes · 12 min read
Designing System Capacity: From Event Scenarios to Precise QPS Planning
FunTester
FunTester
Jun 10, 2021 · Operations

Step‑by‑Step Guide to Testing WebSocket APIs with JMeter

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.

API testingJMeterbackend
0 likes · 6 min read
Step‑by‑Step Guide to Testing WebSocket APIs with JMeter
High Availability Architecture
High Availability Architecture
Jun 2, 2021 · Operations

Design and Implementation of Full‑Link Load Testing at Dada Group

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.

Distributed Systemsload-testingmicroservices
0 likes · 16 min read
Design and Implementation of Full‑Link Load Testing at Dada Group
Dada Group Technology
Dada Group Technology
Jun 1, 2021 · Operations

Design and Implementation of Full‑Link Load Testing at Dada Group

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.

Dada Groupfull‑link testingload-testing
0 likes · 12 min read
Design and Implementation of Full‑Link Load Testing at Dada Group
Zhongtong Tech
Zhongtong Tech
May 28, 2021 · Operations

Why Locust Is the Python Powerhouse for Load Testing: Features, Tips, and Real‑World Insights

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.

Distributed TestingEvent-drivenLocust
0 likes · 10 min read
Why Locust Is the Python Powerhouse for Load Testing: Features, Tips, and Real‑World Insights
FunTester
FunTester
May 28, 2021 · Operations

Scaling Fixed‑QPS Load Tests with a Multithreaded Task Generator

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.

JavaQPSload-testing
0 likes · 5 min read
Scaling Fixed‑QPS Load Tests with a Multithreaded Task Generator
Architecture Digest
Architecture Digest
May 12, 2021 · Backend Development

Performance Optimization of a High‑Concurrency Python Web Service

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.

Backend DevelopmentCachingDatabase
0 likes · 9 min read
Performance Optimization of a High‑Concurrency Python Web Service
Dada Group Technology
Dada Group Technology
May 7, 2021 · Operations

How JD Daojia Built a Scalable Load‑Testing Platform to Reduce Test Time to 15 Minutes

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.

AutomationDistributed SystemsJMeter
0 likes · 12 min read
How JD Daojia Built a Scalable Load‑Testing Platform to Reduce Test Time to 15 Minutes
Test Development Learning Exchange
Test Development Learning Exchange
May 3, 2021 · Operations

Using Locust for Distributed Load Testing: Installation, Script Explanation, and Execution

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.

Distributed TestingLocustPython
0 likes · 7 min read
Using Locust for Distributed Load Testing: Installation, Script Explanation, and Execution
FunTester
FunTester
Apr 19, 2021 · Operations

How to Add a Soft‑Start Mechanism for High‑QPS Performance Testing in Java

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.

ConcurrencyJavahigh QPS
0 likes · 8 min read
How to Add a Soft‑Start Mechanism for High‑QPS Performance Testing in Java
FunTester
FunTester
Apr 6, 2021 · Operations

How Thread Count, Request Volume, and Latency Shape Performance Test Accuracy

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.

BenchmarkingJavaerror analysis
0 likes · 16 min read
How Thread Count, Request Volume, and Latency Shape Performance Test Accuracy
Youzan Coder
Youzan Coder
Apr 2, 2021 · Interview Experience

Inside Youzan's Testing Team: Structure, Practices, and Culture

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.

AutomationTeam Cultureinterview experience
0 likes · 8 min read
Inside Youzan's Testing Team: Structure, Practices, and Culture
FunTester
FunTester
Mar 18, 2021 · Operations

Real‑Time QPS Monitoring and Asynchronous Progress Display for Load Tests

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.

JavaQPSasynchronous progress
0 likes · 12 min read
Real‑Time QPS Monitoring and Asynchronous Progress Display for Load Tests
FunTester
FunTester
Mar 16, 2021 · Operations

How to Capture Per‑API Response Times in Load Tests with Groovy Scripts

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.

Groovybackendload-testing
0 likes · 5 min read
How to Capture Per‑API Response Times in Load Tests with Groovy Scripts
JD Cloud Developers
JD Cloud Developers
Mar 15, 2021 · Operations

Performance Testing Essentials: Metrics, Bottlenecks, and Real-World Optimizations

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.

Optimizationcase studyload-testing
0 likes · 11 min read
Performance Testing Essentials: Metrics, Bottlenecks, and Real-World Optimizations
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Mar 12, 2021 · Operations

Evolution of Live Streaming Load Testing and Stability Assurance for an Online Education Platform

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.

Automationload-testingonline education
0 likes · 12 min read
Evolution of Live Streaming Load Testing and Stability Assurance for an Online Education Platform
FunTester
FunTester
Feb 24, 2021 · Operations

How to Build a Real‑World API Load Test for a Knowledge‑Base Service

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.

API testingJavaOperations
0 likes · 8 min read
How to Build a Real‑World API Load Test for a Knowledge‑Base Service
New Oriental Technology
New Oriental Technology
Feb 22, 2021 · Operations

Full-Chain Load Testing Theory, Model Design (DESP) and New Oriental Continuation Class Case Study

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.

AutomationOperationsSystem architecture
0 likes · 14 min read
Full-Chain Load Testing Theory, Model Design (DESP) and New Oriental Continuation Class Case Study
FunTester
FunTester
Feb 20, 2021 · Backend Development

How I Stress‑Tested a Socket.IO Service with Fixed QPS and Uncovered Hidden Bugs

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.

ConcurrencyJavafixed QPS
0 likes · 10 min read
How I Stress‑Tested a Socket.IO Service with Fixed QPS and Uncovered Hidden Bugs
FunTester
FunTester
Feb 4, 2021 · Operations

Multi‑Chain Performance Testing Demo Using FunTester

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.

FunTesterJavaload-testing
0 likes · 7 min read
Multi‑Chain Performance Testing Demo Using FunTester
FunTester
FunTester
Jan 18, 2021 · Operations

Stress vs. Load Testing: Fixed Threads vs. Fixed QPS Explained

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.

OperationsQPSTPS
0 likes · 5 min read
Stress vs. Load Testing: Fixed Threads vs. Fixed QPS Explained
21CTO
21CTO
Jan 15, 2021 · Operations

How iQIYI Scaled Its Payment System with Full‑Link Load Testing

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.

Operationscapacity planningload-testing
0 likes · 12 min read
How iQIYI Scaled Its Payment System with Full‑Link Load Testing
FunTester
FunTester
Dec 31, 2020 · Operations

Speed Up Load Test Preparation with Java CyclicBarrier

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.

ConcurrencyCyclicBarrierJava
0 likes · 8 min read
Speed Up Load Test Preparation with Java CyclicBarrier
FunTester
FunTester
Dec 17, 2020 · Operations

Multi‑Interface Load Testing for Collect/Uncollect Feature Using FunTester

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.

API performanceFunTesterGroovy
0 likes · 8 min read
Multi‑Interface Load Testing for Collect/Uncollect Feature Using FunTester