Tagged articles
Connection Pooling
50 articles · Page 1 of 1
This article dissects OpenFeign's declarative HTTP client internals, covering JDK dynamic proxy mechanics, load balancing integration, timeout pyramid design, connection pooling, retry disciplines, and common pitfalls with production-ready configurations and source-code walkthroughs.
Connection PoolingJavaOpenFeign
0 likes · 26 min read

This article explains how to determine optimal database connection pool sizes by establishing a capacity budget, monitoring pool and database metrics, configuring HikariCP for PostgreSQL, and iteratively tuning based on workload characteristics rather than relying on generic formulas.
Connection PoolingHikariCPKubernetes
0 likes · 38 min read

This tutorial demonstrates configuring Spring Data RedisTemplate using pure Java annotations, covering Maven dependencies, connection pooling, serialization, and CRUD operations for String, List, Hash, Set, and Sorted Set data types with complete code examples.
Annotation ConfigurationConnection PoolingJava
0 likes · 14 min read


TonyBaiSep 13, 2026 · Backend Development
OpenAI's Habitat storage system evolved from a Python library to a distributed platform handling 70M requests/second for 1B users, with engineers detailing scaling challenges, asyncio tuning, connection pool fixes, and a 2-engineer Rust rewrite using Codex and GPT-5.5 that boosted CPU efficiency 6x and memory efficiency 15x.
AI-assisted codingCodexConnection Pooling
0 likes · 26 min read

This comprehensive guide details a systematic approach to diagnosing and resolving high Redis client connection counts, covering connection models, configuration tuning, CLI analysis commands, application-level connection pool fixes, temporary mitigation tactics, and long-term monitoring best practices with real-world case examples.
CLIENT LISTConnection LeakConnection Pooling
0 likes · 35 min read

This article covers MongoDB document modeling vs relational, embedding vs referencing strategies, Spring Data MongoDB Repository and MongoTemplate usage, aggregation pipelines for analytics, multi-document transactions with avoidance patterns, composite indexing principles, and connection pooling with cursor-based pagination for high-concurrency Spring Boot applications.
Connection PoolingCursor PaginationDocument Modeling
0 likes · 21 min read

This guide covers practical adoption of JDK 21 virtual threads in Spring Boot 3.2+, detailing configuration pitfalls, connection pool tuning, thread pool separation, pinning diagnosis via JFR, monitoring metrics shifts, and a phased rollout strategy for high-concurrency services.
Connection PoolingJDK 21JFR monitoring
0 likes · 13 min read

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.
CachingCompressionConnection Pooling
0 likes · 9 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

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.
Connection PoolingJDBCMySQL
0 likes · 8 min read

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.
CachingConnection PoolingHTTP/2
0 likes · 32 min read

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.
Connection PoolingCost OptimizationKubernetes
0 likes · 9 min read

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.
CloudflareConnection PoolingProxy
0 likes · 8 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

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.
Connection PoolingLinux tuningTCP
0 likes · 11 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

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.
Connection PoolingDatabase ArchitecturePigsty
0 likes · 7 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 6 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 6 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 9 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 6 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

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.
Connection PoolingDBAPIMultithreading
0 likes · 17 min read

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.
Connection PoolingJDBCJava backend
0 likes · 35 min read

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.
BenchmarkConnection Poolingdatabases
0 likes · 10 min read

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.
Connection PoolingHttpClientKeep-Alive
0 likes · 13 min read

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.
Connection PoolingHttpClientJava
0 likes · 11 min read

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.
Connection PoolingCustom Sharding AlgorithmMySQL
0 likes · 16 min read

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.
Connection PoolingIndexingPerformance Tuning
0 likes · 16 min read

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.
Connection PoolingRedisbackend-development
0 likes · 8 min read

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.
Connection PoolingMySQLMySQL Router
0 likes · 7 min read

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.
Connection PoolingHttpClientKeep-Alive
0 likes · 11 min read

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.
Connection PoolingJavaMySQL
0 likes · 8 min read

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.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

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.
Administrative Connection InterfaceConnection PoolingMySQL
0 likes · 9 min read

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.
Connection Poolingbackend architecturehigh concurrency
0 likes · 12 min read


58 TechMay 21, 2021 · Backend Development
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.
Connection PoolingIPCPHP
0 likes · 9 min read

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.
Connection PoolingMySQLPython
0 likes · 38 min read

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.
Connection PoolingProcess Managementasynchronous I/O
0 likes · 18 min read

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.
ConcurrencyConnection PoolingDaemon Thread
0 likes · 6 min read

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.
Connection PoolingMongoDBTaskExecutor
0 likes · 21 min read

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.
ARPConnection PoolingNetworking
0 likes · 8 min read

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.
Connection PoolingJMHJava
0 likes · 8 min read


ITPUBSep 12, 2016 · Databases
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.
ADO.NETConnection PoolingSQL Server
0 likes · 7 min read


ITPUBApr 13, 2016 · Databases
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.
Best PracticesConnection PoolingMySQL
0 likes · 6 min read
