This article shares five practical techniques—cursor‑based pagination, buffered asynchronous logging, server‑side caching, gzip compression, and database connection pooling—that together can shrink API latency from seconds to milliseconds and cut infrastructure costs dramatically.
This article examines the detailed steps and timing of establishing a MySQL connection from Java, measuring over 200 ms per connection, and demonstrates how proper connection closing and connection pooling can dramatically reduce latency in high‑traffic web applications.
This article measures the exact time cost of establishing a MySQL connection from Java, breaks down the TCP handshake, authentication, and protocol steps with Wireshark captures, and shows why connection pooling is essential for high‑traffic web applications.
This article measures the time required to establish and close a MySQL JDBC connection, showing that a single connection can consume over 200 ms, and explains why connection pooling is essential for high‑traffic web applications.
This article dissects the hidden technical debt of internal HTTP APIs, explains why HTTP/1.1 causes head‑of‑line blocking, redundant headers and serialization overhead, and walks through a step‑by‑step, data‑driven optimization roadmap—including HTTP/2, Protobuf, request aggregation, connection pooling, compression, caching, async processing, observability, and safe gray‑release deployment—backed by concrete benchmarks and code samples.
When a sudden 38% rise in AWS bills revealed hidden connection‑storm costs in a Kubernetes‑based microservice architecture, the team introduced PgBouncer as a transaction‑pooling proxy, slashing database connections from over 14,000 to under 400 and cutting monthly cloud spend by more than $300,000, ultimately saving $10.8 million over three years.
Pingora, Cloudflare’s next‑generation proxy built with Rust and Tokio, addresses Nginx’s limitations in large‑scale deployments by introducing a global shared connection pool, asynchronous multithreaded scheduling, programmable hooks, and zero‑downtime hot updates, delivering up to 4× throughput and 70% lower CPU usage.
This article dissects the MySQL connection process in Java, measuring each handshake and authentication step with Wireshark to reveal why establishing a single database connection can consume around 200 ms, and why connection pooling is essential for high‑traffic applications.
The article explains the TCP TIME_WAIT state, why it proliferates under high‑concurrency workloads, its impact on ports, memory and performance, and provides practical application‑level optimizations, cautious OS tuning, and monitoring techniques to mitigate the issue.
This article investigates the time cost of establishing and closing MySQL connections in Java web applications, using Wireshark packet captures and code examples to demonstrate that a single connection can take over 200 ms, highlighting the importance of connection pooling and performance optimizations.
This article investigates the time cost of establishing and closing a MySQL connection from a Java web application, using Wireshark packet captures and simple code examples to quantify latency and illustrate why connection pooling is essential for high‑traffic services.
This article investigates the detailed steps and time consumption of establishing and closing a MySQL connection from a Java web application, using Wireshark packet captures and code examples to demonstrate why connection pooling is essential for high‑traffic services.
The article explains how thousands of simultaneous client connections to a single PostgreSQL primary can cause severe write‑performance degradation, how introducing a connection pool such as pgBouncer reduces active backend processes dramatically, and why external pooling is preferred over built‑in solutions, illustrated with real‑world examples and a reference to the open‑source Pigsty distribution.
This article examines how a Java web application connects to a MySQL database, measuring each step of the TCP handshake, authentication, and setup with Wireshark, and demonstrates that a single connection can take over 200 ms, highlighting the importance of connection pooling.
This article analyzes the detailed steps and timing of establishing and closing a MySQL connection from Java, using Wireshark traces to show that even a minimal connection can consume over 200 ms, highlighting the need for connection pooling in high‑traffic web applications.
This article examines the detailed steps and timing of establishing a MySQL database connection using Java, measures the latency of the TCP handshake and authentication phases, and demonstrates why connection pooling is essential for high‑traffic web applications.
This article investigates the time consumption of creating and closing a MySQL connection from a Java application, measuring each network and protocol step with Wireshark and code examples, and demonstrates why connection pooling is essential for high‑traffic web services.
The article measures the exact time cost of establishing and closing a MySQL connection from Java, breaks down each network and protocol step with Wireshark captures, and shows how these latencies add up to hundreds of milliseconds, making connection pooling essential for high‑traffic web services.
This article examines the detailed steps and performance impact of creating a MySQL connection from a Java web application, measures the latency of the handshake and authentication using Wireshark, and demonstrates why connection pooling is essential for high‑traffic services.
This article investigates the time overhead of establishing MySQL database connections in Java web applications, detailing the TCP handshake, authentication steps, and measured latency using Wireshark, and demonstrates why connection pooling is essential to avoid hundreds of milliseconds per request.
This article explains Python's DB‑API standard, shows how to install and use PyMySQL for MySQL operations, demonstrates basic CRUD commands, safeguards against SQL injection, and provides detailed examples of using DBUtils connection pools with both locking and lock‑free multithreaded approaches.
This article walks through the step‑by‑step JDBC query process, explains why wrapping JDBC in a framework like MyBatis is beneficial, analyzes MyBatis’s core components and execution flow, and presents five practical optimizations—from connection pooling to dynamic SQL and result caching—to improve Java backend performance.
Through a detailed analysis of Oracle and PostgreSQL benchmarks, this article reveals why reducing database connection pool size—often to far fewer than the number of concurrent users—significantly cuts wait times and response latency, and provides a practical formula for sizing pools based on CPU cores and disk resources.
By refactoring a high‑traffic Java service to use a singleton HttpClient, enable connection pooling with a custom keep‑alive strategy, and fine‑tune timeout and retry settings, the average request time dropped from 250 ms to about 80 ms, dramatically improving throughput and stability.
This article details practical optimization techniques for Apache HttpClient—including connection pooling, keep-alive, singleton client usage, proper timeout settings, and asynchronous handling—to reduce average request latency from 250 ms to about 80 ms in a ten-million-calls-per-day service.
This article examines the high connection‑count problem of Sharding-JDBC in JD Logistics, explains sharding concepts, compares four mitigation strategies, and presents a custom table‑partitioning algorithm with configuration changes that dramatically lowers MySQL instance connections while maintaining performance.
This article outlines the ten most frequent PostgreSQL pitfalls—from default configurations and poor schema design to inadequate backups and mismanaged extensions—providing concrete SQL queries, tuning tools, and best‑practice recommendations to help DBAs detect, diagnose, and prevent each issue before it harms production workloads.
This article explains how to integrate Redis into a Rust backend by defining resource structs, wrapping the redis‑rs client, implementing a connection manager for r2d2, creating a global singleton pool with OnceCell, and demonstrating basic CRUD operations through example code.
The article investigates why MySQL Router 8.0.29/8.0.30 reports “ERROR 1040 (HY000): Too many connections to MySQL Router” even when the backend MySQL server has only a few connections, reproduces the issue, analyzes packet traces, and concludes that the problem exists in those versions but not in 8.0.28 or 8.0.21, likely due to a new connection‑pooling feature.
This article explains how to dramatically reduce the average response time of a high‑traffic Java service from 250 ms to about 80 ms by applying HttpClient pooling, keep‑alive strategies, proper timeout settings, and idle‑connection monitoring, complete with code examples and configuration details.
This article analyzes the full lifecycle of a MySQL connection from Java code to TCP handshake using Wireshark, measures each step’s latency, calculates the total cost per request, and demonstrates why connection pooling is essential for high‑traffic web applications.
This article investigates how much time a simple Java program spends establishing and closing a MySQL connection, measures the latency of each TCP and MySQL handshake step with Wireshark, and demonstrates why connection pooling is essential for high‑traffic web services.
The article explains why MySQL can hit the max_connections limit, introduces the MySQL 8.0 administrative connection interface and its configuration variables, demonstrates how to create a privileged user and test connection limits with code examples, and offers best‑practice recommendations to prevent connection saturation.
This article explains how to design backend architectures that meet the "three high" goals—high concurrency, high performance, and high availability—by using load balancing, connection pooling, traffic filtering, multi‑level caching, log optimization, and failover strategies.
The article explains the core idea of pooling to trade space for time, analyzes the shortcomings of in‑process connection pools in PHP‑FPM, proposes long‑connection and cross‑process pooling solutions using Swoole’s IPC mechanisms, and demonstrates significant CPU and latency improvements in a real‑world high‑concurrency backend.
This tutorial explains how to perform asynchronous MySQL operations in Python using aiomysql, covering basic connections, CRUD actions, safe parameter handling to prevent SQL injection, connection pooling, transaction management, integration with SQLAlchemy for ORM queries, and a custom reconnection wrapper for resilient database access.
This article explains Nginx's high‑performance architecture, covering its daemon mode with master and worker processes, the thundering‑herd problem, advantages of process‑based concurrency, asynchronous non‑blocking I/O, connection handling, keep‑alive and pipeline techniques, as well as key internal data structures such as arrays, queues, lists, strings, memory pools, hash tables, and red‑black trees.
This article explains multithreading fundamentals, covering thread concepts, lock mechanisms for database access, deadlock causes and solutions, recursive locks (RLock), data race issues, and daemon thread behavior. It also discusses connection pooling, timeout strategies to avoid deadlock, and practical code examples in Python.
This article explains how MongoDB's mongos router manages client‑to‑mongos and mongos‑to‑mongod connections, compares the default per‑connection‑per‑thread model with the adaptive thread‑pool introduced in version 3.6, details the internal traditional and ASIO connection pools, relevant configuration parameters, and provides practical guidance on interpreting connection‑pool statistics.
The article investigates intermittent TCP connection failures during application server startup caused by the Linux kernel ARP queue length parameter unres_qlen, reproduces the issue with a concurrent connection test, analyzes kernel internals, and recommends increasing unres_qlen for kernels prior to 3.3.
This article investigates the performance differences between the Connection and Template modes of Venus‑cache, presenting test scenarios on physical and cloud servers, analyzing throughput, lock contention, and thread behavior, and offering a solution to improve QPS by optimizing connection handling.
When a timeout error occurs because the connection pool is full, you can use sp_who or sp_who2 to list active SQL Server sessions, interpret sleeping processes, understand ADO.NET pooling behavior, and employ SQL Server Profiler to pinpoint why connections are not being reused.
Closing database connections promptly is essential for performance and availability, and this guide explains practical rules, connection‑pool benefits, safe coding patterns, exception handling, and how to diagnose lingering connections using MySQL's SHOW PROCESSLIST command.
