The article explains how Redis achieves more than 100,000 queries per second by leveraging in‑memory storage, highly optimized data structures, a single‑threaded core with epoll‑based I/O multiplexing, optional I/O multithreading, and performance tricks such as pipelining and careful key sizing.
Redis can sustain over 100,000 queries per second thanks to four key factors: pure in‑memory storage, highly optimized data structures such as SDS and ziplist, a single‑threaded event loop with epoll‑based I/O multiplexing, and optional multi‑threaded network handling introduced in Redis 6.0.
Redis can sustain over 100,000 queries per second thanks to four key pillars—memory‑first storage, highly optimized data structures like SDS and skip lists, a single‑threaded event loop with epoll multiplexing, and multi‑core I/O threading—each explained with benchmarks, code samples, and real‑world comparisons.
This article breaks down Redis performance limits, showing that a single node can handle roughly 100‑200k simple GET/SET QPS and up to 500‑700k with multithreaded I/O, while sharded clusters can theoretically reach millions of QPS, though practical factors affect the actual throughput.
The article explains high‑concurrency scenarios and how to quantify them using QPS (queries per second) and TPS (transactions per second), highlighting their definitions, typical system capacities, and the distinction between request‑level and business‑level throughput.
This guide breaks down five common QPS measurement techniques—from load balancer logs and Java instrumentation to APM tools and database metrics—detailing their principles, pros and cons, real‑world pitfalls, and provides Java code examples and optimization strategies for accurate, real‑time monitoring.
This article provides a comprehensive framework for evaluating system support capability by defining QPS excellence thresholds across industry benchmarks, business types, response time, resource efficiency, performance metrics, architectural guidelines, optimization tactics, and real‑world case studies, culminating in a practical calculation formula.
This guide explains what QPS is, outlines three practical methods to estimate it—including business‑scenario modeling, historical data analysis, and industry benchmarking—covers key influencing factors, shows formulas linking QPS, concurrency and response time, and recommends tools and best‑practice tips for reliable capacity planning.
When MySQL QPS reaches 10,000, common bottlenecks include CPU saturation, low buffer pool hit rate, connection limits, and lock contention, which can be mitigated through internal tuning, cache interception, read‑write splitting, and horizontal sharding.
This article explains how TPS (transactions per second), QPS (queries per second), and concurrency differ, shows how each metric is calculated with concrete examples, and clarifies their relationship for evaluating system throughput and resource usage in high‑load environments.
This article explains what QPS (queries per second) really means, distinguishes it from TPS and concurrency, shows typical QPS ranges for different systems, and provides practical methods—production monitoring, APM tools, custom metrics, load‑testing and manual estimation—to obtain, validate, and interpret QPS for performance optimization and interview success.
This article explains core performance metrics such as QPS, TPS, and concurrency, introduces related indicators like PV, UV, DAU/MAU, describes how to calculate system throughput, outlines testing perspectives, and provides practical design patterns and tips for building robust flash‑sale systems.
This article explains five practical ways to count QPS—from gateway and application instrumentation to monitoring tools, log analysis, and database metrics—while highlighting common pitfalls such as health‑check filtering, thread‑safety, and multi‑node aggregation, helping engineers make informed scaling decisions.
This article explains how to determine a 100 000‑QPS rate‑limiting threshold by covering the purpose of throttling, the three core elements of limiting, common algorithms, target dimensions, capacity estimation for single‑service and full‑link scenarios, pressure‑testing techniques, monitoring data, and adaptive configuration strategies.
This comprehensive guide explains what stress testing is, why it matters, key terminology, calculation methods, traditional tools, and introduces a lightweight Go-based load testing utility with detailed usage examples, parameters, and best‑practice recommendations for accurate performance evaluation.
This article details a systematic performance test of OceanBase's online DDL capabilities, measuring TPS and QPS impacts across various DDL operations, describing the test environment, scripts, results, and conclusions for reliable database schema changes.
This article explains the key performance metrics TPS (transactions per second) and QPS (queries per second), provides formulas for calculating them, and demonstrates practical calculations for multi-node deployments, illustrating how request latency, thread pools, and instance count affect overall system concurrency and throughput.
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 defines high concurrency, outlines QPS thresholds for small, medium, high, and ultra‑high traffic, and presents practical solutions such as multi‑level caching, load balancing, database sharding, and message‑queue traffic shaping to build robust backend systems.
This article explains the meanings, calculations, and differences of key high‑performance metrics such as system throughput, QPS, TPS, response time, and concurrency, illustrating each concept with real‑world examples and visual diagrams to help engineers evaluate and optimize large‑scale systems.
This article explains how to restrict a third‑party API to five requests per second in Go by combining a rate limiter to pace job starts and a semaphore to cap concurrent executions, complete with a full, runnable code example and detailed implementation notes.
This article presents a Go‑based dynamic QPS load‑testing framework that leverages a custom goroutine pool, explains the rationale behind reusing goroutines, provides core functions for task execution and console command handling, and includes a complete runnable demo illustrating high‑throughput performance testing.
This article explains the definitions and differences of QPS and TPS, describes concurrency and throughput concepts, introduces related metrics such as PV, UV, DAU, MAU, and outlines key considerations for system performance testing and capacity planning.
This article explains the definitions and differences between QPS and TPS, explores related concepts such as concurrency, throughput, PV, UV, DAU, MAU, and outlines practical methods for evaluating system performance and capacity planning.
This article explains how Java architects should select appropriate MySQL database machine configurations, collaborate with DBAs for deployment, and conduct essential performance and load testing, covering QPS vs TPS, IOPS, throughput, latency, and other critical metrics for production environments.
This article explains a Java technique for limiting asynchronous task execution to a fixed queries‑per‑second rate using a Semaphore‑based thread pool, a LinkedBlockingQueue, and a daemon thread that manages task dispatch, shutdown, and idle waiting.
This article explains how to use Java's java.util.concurrent.Semaphore together with a fixed-size thread pool to enforce a precise QPS limit for asynchronous tasks, providing API details, implementation steps, and a complete test example.
The article explains the core performance metrics QPS, TPS, response time (RT), concurrency, and throughput, provides formulas to relate them, demonstrates practical calculations for capacity planning, and discusses how to determine the optimal number of threads for a backend system.
This article explores the QPS threshold required to expose thread‑unsafe operations such as i++ by designing a SpringBoot service, running controlled load tests with both fixed‑thread and precise‑QPS models, and presenting detailed results that show how error rates increase with higher request rates.
This article explains the key performance metrics of backend systems—including QPS, TPS, response time, concurrency, and throughput—provides their definitions, relationships, practical calculation examples, and guidance on optimal thread counts for achieving balanced performance.
This article walks through designing three Redis Stream performance test cases—adding, reading, and add‑delete—using dynamic thread and dynamic QPS models in Java, provides complete Groovy‑based test code, and shows sample console output for evaluating throughput and latency.
This guide walks through creating a SpringBoot service, adding Sentinel dependencies, writing a high‑traffic test endpoint, explaining Sentinel’s entry/exit logic, and configuring the Sentinel dashboard to enforce a single‑node QPS limit of 20, complete with code samples and screenshots.
This article explains a refined approach for implementing QPS and response‑time samplers in a Java performance‑testing framework, covering static and dynamic load models, the use of LongAdder, thread‑count utilities, and detailed code examples for reliable metric collection.
The author shares a deep‑dive performance analysis of the FunTester framework, comparing Java and Groovy implementations, detailing JVM tuning, hardware usage, and practical tips that enabled a single Groovy process to sustain 110,000 QPS while outlining when distributed testing and connection‑pool sizing become necessary.
This article details a practical reproduction of a large‑scale WeChat red‑packet service, describing the design goals, hardware and software setup, concurrency architecture, monitoring tools, and performance results that demonstrate a single‑machine handling one million connections and up to sixty thousand queries per second.
This article details the design, goals, hardware and software choices, implementation techniques, performance testing phases, and analysis of a prototype backend capable of handling one million concurrent connections and up to 60 k QPS to simulate the massive load of ten billion WeChat red‑envelope requests.
This article explains how to design and evaluate system capacity by defining key metrics such as QPS, TPS and concurrency, describing when capacity assessment is needed, and outlining a step‑by‑step methodology—including traffic analysis, peak estimation, stress testing and redundancy planning—to ensure reliable performance under varying load conditions.
This article details the end‑to‑end preparation, execution, reporting, and retrospective of a large‑scale production‑environment load test for the Double 11 shopping festival, covering data preparation, QPS target calculation, multi‑scenario testing, issue analysis, and continuous improvement practices.
The article explains how to assess system capacity by analyzing daily traffic, calculating average and peak QPS, applying the 80/20 rule, conducting stress tests, and adjusting resources, illustrated with a sports event example and a book reservation system case study.
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 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 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.
This article explains the definitions of QPS (queries per second) and TPS (transactions per second) in MySQL, compares the various calculation methods—including Queries‑per‑second, Questions‑per‑second, and GTID‑based approaches—and recommends the most reliable ways to measure database load and transaction throughput.
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 explains the definitions of QPS and TPS, compares their meanings, explores related metrics such as concurrency, throughput, PV, UV, and DAU, and outlines key performance testing concepts and evaluation methods for system capacity and user experience.
This article explains how to estimate and design system capacity by analyzing daily traffic, calculating average and peak QPS, applying the 80/20 rule, performing stress tests, and adjusting resources to handle temporary spikes, initial launches, and growing workloads.
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 explains how adaptive sampling reduces the performance and storage impact of full‑link tracing by dynamically adjusting the sampling rate based on application QPS, outlines the mathematical model, discusses implementation details such as warm‑up, QPS lag, concurrency, and provides a Java reference sampler.
This article clarifies core web‑service metrics—QPS, TPS, PV, UV, DAU, MAU—explains their differences, shows how concurrency and throughput relate, and outlines key performance‑testing concepts and evaluation methods for modern system capacity planning.
This article explains core web performance metrics such as QPS, TPS, PV, UV, DAU, MAU, concurrency, and throughput, clarifies their differences, and outlines how to evaluate system capacity and performance from user, administrator, and developer perspectives.
This article explains how to assess and design system capacity by analyzing real‑world scenarios—such as a company sports event—calculating required concurrency, average and peak QPS using the 80/20 rule, performing load tests, and determining instance counts to ensure reliable performance under varying traffic spikes.
This 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 investigates why Sentinel’s QPS threshold of 20 is triggered at 15, analyzing metric logs, the underlying MetricNode and MetricTimerListener code, and revealing a timing discrepancy between second‑level and minute‑level counters that can cause premature flow‑control blocking.
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.
The article explains why a single‑threaded request generator fails at high QPS, introduces a multithreaded generator with a configurable per‑thread QPS limit, provides the full Java implementation, and shows that it reliably sustains 10‑20k QPS in practice.
This article 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 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 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 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 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.
Using sysbench, this study benchmarks MySQL 5.7.22 and MySQL 8.0.15 under read‑write, read‑only, and write‑only workloads with various sync_binlog and innodb_flush_log_at_trx_commit settings, revealing performance trends across different concurrency levels and highlighting that MySQL 5.7 often outperforms 8.0 in these tests.
This article details the design, implementation, and performance testing of a Go‑based backend that simulates a Spring Festival red‑packet system capable of handling up to 6 × 10⁴ QPS and one million concurrent connections, demonstrating how to achieve 10 billion request processing in a controlled environment.
This article explains the definitions and differences of QPS and TPS, how they relate to concurrency and system throughput, and introduces related metrics such as PV, UV, DAU, response time, and practical considerations for performance testing and capacity planning.
This article explains how to improve a fixed QPS mock interface in Java by adding a compensation thread that adjusts request timing using a thread‑safe counter, reducing error beyond the original 5% tolerance.
This article introduces the Hey load‑testing tool, explains how to install and run it with specific QPS settings, analyzes the resulting metrics and charts, and offers practical tips for identifying bottlenecks such as network bandwidth or CPU usage during capacity planning.
This article explains how to retrieve and interpret key MySQL performance metrics—including TPS, QPS, thread status, InnoDB I/O, buffer pool health, MyISAM statistics, temporary tables, response time, and replication lag—using mysqladmin, SHOW GLOBAL STATUS, and Percona tools, with practical calculation formulas and command examples.
This article explains core performance metrics such as Queries Per Second (QPS) and Transactions Per Second (TPS), distinguishes their differences, introduces related concepts like concurrency, PV, UV, and DAU, and outlines how to evaluate system throughput and conduct basic performance testing.
This article explains the definitions and differences of QPS and TPS, clarifies concurrency and throughput concepts, introduces related metrics such as PV, UV, DAU, and MAU, and outlines key performance testing considerations for system design and capacity planning.
This article details a practical experiment that reproduces the load of 100 billion WeChat red‑packet (shake‑and‑grab) requests by simulating 1 million concurrent users on a single machine, achieving peak QPS of 60 k and demonstrating the architectural choices, hardware setup, and monitoring techniques required for such high‑throughput backend systems.
The article explains how Youku’s engineers mitigate extreme traffic spikes during large‑scale events by applying three core techniques—staggering requests across time, enforcing client‑side rate limits, and cutting peaks through minimum intervals, probabilistic sending and fairness algorithms—to lower maximum QPS, improve stability, and preserve user experience.
This article explains why simply increasing thread‑pool size often fails, describes how CPU, network and disk I/O affect request handling, introduces the concept of context switching, and provides practical formulas and guidelines for calculating the optimal number of threads in a Java backend service.
Learn how response time (RT), queries per second (QPS), concurrent user count, and optimal thread settings interrelate, using a Disney park analogy to illustrate calculation methods and performance tuning strategies for web applications.
This article translates and expands on Mark Callaghan’s sysbench benchmark, revealing that MySQL 5.6‑5.7 suffers the steepest QPS drop in low‑concurrency tests, compares configurations across versions, presents detailed charts, and concludes that most performance regressions are isolated to the 5.7 release.
This article details how to design, implement, and benchmark a single‑machine backend capable of handling up to 1 million concurrent connections and 60 000 queries per second while simulating the shake‑and‑send red‑packet workflow of a large‑scale messaging app, including capacity calculations, architecture choices, Go‑based implementation, and multi‑stage performance testing.
This article describes how to design, implement, and evaluate a backend system that simulates the Spring Festival red‑packet service, achieving up to 6 × 10⁴ QPS on a single server while handling one million concurrent connections, and discusses the hardware, software, architecture, and performance results.
This article explains key performance testing concepts such as system throughput, QPS/TPS, concurrency, response time, and their interrelationships, provides practical calculation examples, shows how daily PV relates to TPS for different platforms, and outlines essential metrics and formulas for evaluating software performance.
Benchttp is a minimal‑weight Go‑based load‑testing utility that lets you measure QPS, duration, and concurrency with simple command‑line flags, and the article explains its usage, common parameters, and step‑by‑step installation on Linux.
This article explains essential software performance testing concepts—including QPS/TPS, concurrency, response time, throughput calculations, think time, and how to estimate daily traffic using real‑world examples from e‑commerce platforms—providing formulas and practical guidance for engineers, administrators, and developers to assess and optimize system capacity.
This article explains core performance testing concepts—including QPS, concurrency, response time, and throughput calculations—illustrates how to estimate system capacity, relate traffic metrics to daily PV, and outlines the perspectives of users, administrators, developers, and test engineers for evaluating software performance.
