This comprehensive guide covers HikariCP internals, core parameter tuning, connection leak detection, handling MySQL wait_timeout disconnections, preventing cascade failures, production-ready configuration examples, monitoring with Micrometer, and comparison with Druid for Spring Boot applications.
A real-world case study shows how systematic profiling with Spring Boot Actuator and JFR, combined with scan-scope reduction, selective @Lazy on external clients, HikariCP deferred connection, and ApplicationReadyEvent-driven async initialization cut a Spring Boot 3.1.5 order-service startup from 6.2 seconds to 1.8 seconds on Java 17.
An API's sudden latency spike from 200ms to 8 seconds was traced not to slow SQL but to database connection pool exhaustion caused by @Transactional methods holding connections during external HTTP calls to a payment service; splitting transactions and moving external calls outside the transaction boundary resolved the issue.
After upgrading to Java 25 and Spring Boot 4, the author enabled virtual threads and removed custom thread pools for IO-heavy aggregation endpoints. While code simplified dramatically, the bottleneck shifted from thread exhaustion to HikariCP connection pool exhaustion, revealing that virtual threads don't increase downstream capacity. The solution: limit scarce resources (DB connections, HTTP clients) directly rather than limiting threads.
The article explains that true concurrent user testing must emulate realistic user sessions with think time and asynchronous actions, identifies three typical bottlenecks—application thread blocking, database connection pool exhaustion, and middleware resource contention—and demonstrates proactive performance‑left‑shift practices and emerging AI‑driven adaptive testing techniques.
The article explains how a fast SQL statement can occupy a database connection for hundreds of milliseconds because Spring’s @Transactional starts the transaction and acquires the connection long before the first JDBC statement, and shows how the new Spring Boot 4.1 `connection‑fetch: lazy` setting postpones the acquisition to solve the problem.
The article walks through a real incident where a scheduled batch job contained an infinite while‑true loop, causing all 500 HikariCP connections to be held, slowing the application dramatically; it details the investigation steps, root‑cause analysis, and both emergency and long‑term fixes, plus a checklist to avoid similar bugs.
This article walks through a systematic approach to sizing PostgreSQL connection pools for Java applications using HikariCP and Spring Boot, covering capacity budgeting, workload‑driven calculations, monitoring metrics, slow‑SQL analysis, leak detection, Kubernetes deployment considerations, and safe rollout practices.
This article details a production-hardened Spring Boot integration with HashiCorp Vault for centralized secret management, covering Kubernetes Auth and AppRole authentication, dynamic database credential issuance, lease renewal aligned with HikariCP connection pools, security policies, audit logging, high-availability Raft deployment with Auto-Unseal, and practical patterns for config reload, fallback, and multi-environment isolation.
This article examines five practical ways to improve Spring Boot 3.5.0 transaction performance—read‑only transactions, explicit propagation settings, correctly sized HikariCP pools, JDBC prepared‑statement caching, and Hibernate batch writes—showing the underlying overhead and providing concrete code and configuration examples.
A sudden surge in traffic caused a signature interceptor's synchronous database insert to consume all HikariCP connections, crashing core services, and the author resolved it by converting the operation to asynchronous execution while outlining more robust long‑term solutions.
A production incident where core API latency spiked from 50ms to 30s+ due to connection leaks and exhausted MySQL max_connections is dissected, revealing how default HikariCP settings become time bombs under load and how to build a defense system with leak detection, parameter tuning, slow SQL interception, and kill mechanisms.
Even with less than 30 QPS and normal DB CPU, a connection pool can run out in two hours because connections are held too long—often due to leaks, long‑running transactions, or async misuse—so the root cause must be traced back to the application code rather than just slow SQL.
This article walks through the principles of database connection pools, common causes of pool exhaustion such as leaks, mis‑configuration, slow SQL and DB limits, and provides a step‑by‑step methodology with monitoring, thread‑stack analysis, and concrete configuration and SQL optimizations to restore stability.
This article compares Druid and HikariCP, the two most popular Java database connection pools, by explaining how connection pools work, presenting benchmark results, dissecting HikariCP's lock‑free design and bytecode optimizations, detailing Druid's rich monitoring and security features, and offering a practical decision framework for different scenarios.
The article compares Alibaba’s Druid and Spring Boot’s default HikariCP connection pools, explaining how connection pooling works, presenting benchmark results that show HikariCP’s lower latency and higher TPS, detailing HikariCP’s lock‑free ConcurrentBag and bytecode optimizations, and highlighting Druid’s rich monitoring, SQL firewall and leak detection features to help developers choose the right pool for different scenarios.
Spring Boot 4.1 makes virtual threads the default, dramatically increasing I/O concurrency, yet the unchanged HikariCP maximumPoolSize can exhaust connections; the article explains this incompatibility, shows how to adjust pool settings, enable lazy connections, and outlines a step‑by‑step migration path from 3.x to 4.1.
This article explains why HikariCP is the default Spring Boot connection pool, details the required dependencies, walks through essential configuration parameters, shows how to use HikariTemplate, monitor pool metrics, avoid common pitfalls, and compares HikariCP with other popular pools.
This article explains why basic Spring Boot datasource settings are insufficient for production and walks through five advanced configurations—HikariCP tuning, transaction timeout and isolation, read‑write splitting, slow‑SQL monitoring, and security hardening—each illustrated with concrete code snippets and rationale.
A production incident where payment orders appeared successful but were not persisted was traced to a missing commit in a special‑case branch, causing a polluted connection to be reused by Spring's transaction manager, leading to intermittent failures that were resolved by fixing the commit logic and adding connection‑pool health checks.
The article shows how ChatGPT examines JMeter load‑test results, identifies CPU, database and I/O bottlenecks, and then proposes concrete optimizations such as adding indexes, tuning HikariCP pool settings, caching, code refactoring, and monitoring to improve login throughput and latency.
SpringBoot’s out‑of‑the‑box defaults—such as Tomcat’s tiny connection pool, HikariCP’s 10‑thread limit, lazy‑loaded JPA entities, system‑timezone JSON serialization, un‑rolled Logback files, unlimited in‑memory cache, exposed Actuator endpoints, tiny file‑upload limits, per‑task thread creation for @Async, and unlimited transaction timeouts—can silently cripple production systems, so each must be reviewed and tuned for real‑world workloads.
This article explains the importance of database connection pools in Spring Boot projects using KingbaseES, compares four popular pools (DBCP, C3P0, Druid, HikariCP), provides configuration examples, highlights common pitfalls, and offers practical tuning and monitoring guidance for optimal performance.
This article walks through ten practical Spring Boot configuration optimizations—including Tomcat connection pool, HikariCP, Jackson timezone handling, Logback rotation, Caffeine caching, Actuator endpoint exposure, file upload limits, async thread pools, static resource caching, and transaction timeouts—providing ready‑to‑use YAML snippets and clear explanations for each setting.
Discover six practical Spring Boot optimization techniques—including Tomcat thread‑pool tuning, @Async asynchronous processing, HTTP caching, switching to Undertow, HikariCP connection pooling, and JVM memory settings—that transformed a sluggish e‑commerce service from 5‑second delays to sub‑1.5‑second response times.
This article explains Java object pooling using Commons Pool 2 and HikariCP, covering their core classes, configuration parameters, practical examples with Redis and JDBC, interview questions, and JMH performance benchmarks that demonstrate significant throughput improvements.
This guide explains the need for JDBC connection pools, compares popular pools like HikariCP and Druid, and provides step‑by‑step configurations for both custom property files and Spring Boot auto‑configuration, helping you efficiently manage database connections in Java applications.
This article explains the principles of object pooling in Java, introduces the Commons Pool 2 library and its use in Redis client Jedis, compares pool and non‑pool performance with JMH benchmarks, and details the fast HikariCP database connection pool along with configuration tips and interview questions.
The article examines Java connection pool technologies, comparing Commons Pool 2 with HikariCP and showing through JMH benchmarks that HikariCP delivers up to five‑times higher throughput, while detailing lifecycle management, configuration, eviction strategies, sizing best practices, and real‑world uses such as database, HTTP, and RPC connections.
This article explains the core concepts of connection‑pool technology, details the architectural choices behind HikariCP such as dual HikariPool instances, FastList, custom ConcurrentBag, ThreadLocal caching, and byte‑code generation, and walks through the key source code that makes the pool exceptionally fast.
This article explains the concept of database connection pools, why they are needed, their core principles and runtime mechanisms, compares traditional direct connections with pooled connections, and reviews major Java pool implementations such as DBCP, C3P0, Druid and HikariCP along with configuration tips and best‑practice considerations.
After an Alibaba Cloud RDS host failure caused a HA switch, the bme‑trade‑order‑svc service experienced prolonged unavailability; this article dissects how thread‑pool saturation, HikariCP connection‑pool mechanics, and CPU load interplay, and outlines systematic investigations that pinpointed thread waiting, pod restarts, and CPU throttling as root causes.
This article examines why HikariCP, the default Spring Boot 2.0 connection pool, achieves high performance by exploring its design concepts such as dual HikariPool instances, FastList, custom ConcurrentBag, thread‑local caching, and bytecode optimization, and includes sample Maven configuration and Java code.
This guide shows how to configure Spring Boot, MyBatis‑Plus and the dynamic‑datasource starter to connect to MySQL, SQL Server and PostgreSQL, add and remove data sources at runtime, verify their availability, and perform manual switching using a utility class and functional interfaces.
This article examines the design and implementation details of HikariCP—Spring Boot's default JDBC connection pool—explaining how its dual‑pool architecture, FastList collection, custom ConcurrentBag, bytecode‑level optimizations, and efficient connection acquisition and release mechanisms together deliver exceptional performance for Java backend applications.
This guide explains how to implement read‑write separation in Spring Boot applications by configuring master and slave databases, creating dynamic routing data sources, using custom annotations and AOP, integrating HikariCP and MyBatis, and handling thread‑local context for optimal performance.
This guide walks through setting up a Spring Boot 2.4.12 project with JDK 1.8, Oracle, and two data sources—master and slave—covering Maven dependencies, application.yml settings, custom property classes, HikariDataSource beans, JPA EntityManagerFactory, MyBatis SqlSessionFactory, mapper scanning, and testing entity creation to verify successful configuration.
This article translates and expands on HikariCP's pool‑sizing guidance, explaining why smaller database connection pools often yield better performance, presenting real‑world benchmark data for various pool sizes, and offering a simple formula to calculate an optimal pool size based on CPU cores and effective disks.
This article explains Java object pooling concepts, introduces the Commons Pool 2 library, demonstrates its use with Redis via Jedis, compares performance with JMH benchmarks, and discusses the high‑performance HikariCP database connection pool, including configuration tips and common interview questions.
This article explains the principles of object pooling in Java, introduces the Commons Pool 2 library, demonstrates its use with Redis client Jedis, compares performance with JMH benchmarks, and discusses the high‑performance HikariCP database connection pool, including configuration tips and interview questions.
This article explains the principles of object pooling in Java, introduces the Commons Pool 2 library, demonstrates its use with Redis client Jedis, compares performance with JMH benchmarks, and details the configuration and advantages of the high‑performance HikariCP database connection pool.
This article translates and expands on a HikariCP wiki post, showing how dramatically reducing database connection pool size—from thousands to just a handful—can cut response times from around 100 ms to 3 ms, backed by Oracle and PostgreSQL benchmarks and a practical sizing formula.
This article recounts a real‑world investigation of a MySQL high‑availability outage where HikariCP connections appeared to dead‑lock, detailing the architecture, observed symptoms, code analysis, thread‑dump findings, and the final fix of adding socket timeout parameters to the JDBC URL.
This article explains how HikariCP's lock‑free ConcurrentBag manages database connections using ThreadLocal caches, a CopyOnWriteArrayList, AtomicInteger waiters, and a SynchronousQueue, and walks through the key code for borrowing and returning connections to improve Java multithreaded performance.
This article explains why pooling costly resources like database connections improves performance, introduces the Commons Pool 2 library and its core classes, demonstrates a Jedis pool with JMH benchmarks showing a 5× throughput boost, and dives into HikariCP's optimizations, configuration tips, and common interview questions.
This article explains the motivation behind object pooling in Java, walks through the core classes of Commons Pool 2 with a Jedis example, details key configuration parameters, presents JMH benchmark results that show a five‑fold throughput gain, and analyzes HikariCP’s design tricks and common interview questions about pool tuning.
This article explains Java object pooling concepts, introduces the Commons Pool 2 library and its usage with Redis's Jedis client, compares it with the high‑performance HikariCP database connection pool, and presents JMH benchmark results demonstrating significant throughput gains, while also covering configuration parameters and interview questions.
This article explains how object pooling in Java—using Commons Pool 2, the Jedis Redis client, and the HikariCP database connection pool—can dramatically improve performance by reusing expensive resources, detailing key configuration parameters, benchmark results, and practical tuning advice.
This article translates and expands on a HikariCP wiki post, explaining why a small database connection pool often yields better performance than a large one, presenting benchmark data, a practical sizing formula, and guidance for tuning pools in various environments.
After deploying a project, a 500 Server Error appears the next day due to MySQL closing idle connections after the default 8‑hour wait_timeout, and the article explains how to verify the issue, adjust wait_timeout, use autoReconnect, and properly configure the HikariCP connection pool to prevent the failure.
A mysterious issue where some MySQL queries return only one row after executing SET SQL_SELECT_LIMIT=1 is traced to the MySQL driver’s Statement.setMaxRows method, which sets a session variable that can pollute pooled connections, leading to unexpected row limits.
This article explains how HikariCP, the default Spring Boot 2.x connection pool, improves database performance through byte‑code optimization, custom containers, and streamlined code, and it details the internal classes, lifecycle methods, configuration, monitoring, and practical usage examples.
This article provides a detailed analysis of HikariCP’s initialization, core components, startup flow, connection acquisition logic, monitoring metrics, and key configuration parameters, illustrating how Spring Boot 2.x leverages this high‑performance JDBC connection pool and offering guidance for tuning and extending it.
This guide walks through setting up a Spring Boot 2.1.4 application with JDK 1.8, Oracle, and HikariCP to use separate master and slave data sources, covering Maven dependencies, YAML configuration, custom property classes, JPA EntityManager factories, MyBatis SqlSession factories, mapper scanning, and sample entity definitions.
The article explains how to determine the optimal size of a database connection pool by analyzing performance tests, presenting a simple formula based on CPU cores and disk count, and demonstrating that a much smaller pool can dramatically improve response times for high‑concurrency workloads.
This article translates and expands on a HikariCP wiki post, explaining why smaller database connection pools often yield better performance, presenting benchmark videos and data, describing the underlying CPU, disk, and network constraints, and offering a simple formula to calculate an optimal pool size for typical server configurations.
The article explains why a small database connection pool combined with a large queue of waiting threads yields better performance, illustrates this with Oracle and PostgreSQL benchmark data, and provides a practical formula for calculating the optimal pool size based on CPU cores and effective disks.
The article explains how HikariCP outperforms other JDBC pools by using bytecode‑generated proxies, a custom FastList, and a thread‑local ConcurrentBag, delivering superior speed, low resource use, and easy migration, making it the default high‑performance connection pool for Spring Boot 2.0.
This article explains why a small database connection pool often yields better performance, presents real‑world Oracle and PostgreSQL benchmark results, discusses CPU, disk and network bottlenecks, and provides a practical formula for calculating the optimal pool size based on core count and effective disks.
This article examines HikariCP’s FastList, a custom list built on ArrayList that removes range checks and overrides key methods, explaining how these optimizations—such as a faster add operation, a new removeLast method, and unsupported bulk operations—boost the performance of the database connection pool.
The article explains why a small database connection pool often yields better performance than a large one, illustrates the point with Oracle and PostgreSQL benchmark data, and provides a simple formula to calculate the optimal pool size based on CPU cores and effective disks.
This article explains why a smaller database connection pool often yields better latency and throughput, illustrates the effect with Oracle and PostgreSQL benchmarks, and provides a practical formula (connections = (CPU cores × 2) + effective disks) for sizing pools in production systems.
This article explains how reducing the size of a database connection pool can dramatically lower request latency and improve throughput, using HikariCP performance experiments, a simple sizing formula, and practical guidelines for configuring pools on modern hardware.
This article explains the concept of a DataSource, compares it with core JDBC APIs, and provides a step‑by‑step guide to configuring Spring Boot 2.x’s default HikariCP connection pool, including common properties, their meanings, and links to full example projects.
An in‑depth guide walks through HikariCP’s seven most useful monitoring metrics, explains their types, shows real‑world examples of connection storms and slow SQL, and provides step‑by‑step troubleshooting methods, code insights, and configuration tips to keep your database connection pool healthy.
This article explains how idle TCP connections are silently dropped by Alibaba Cloud security groups, causing Redis client timeouts and MySQL JDBC CommunicationsExceptions, and provides step‑by‑step diagnostics and configuration changes—including TCP keepalive and wait_timeout tweaks—to prevent the failures.
This article provides a comprehensive technical overview of Sharding-Proxy, covering its transparent MySQL‑protocol design, internal architecture, PreparedStatement optimization, HikariCP tuning, result‑set streaming, memory‑strict and connection‑strict modes, and practical configuration tips for high‑performance database proxying.
This article compiles and translates key information about HikariCP, detailing why Spring Boot 2 adopts it as the default JDBC pool, comparing its performance and stability against BoneCP, C3P0, Tomcat and Druid, and providing practical configuration steps for quick integration.
This article reviews mainstream Java database connection pools—including C3P0, DBCP, Tomcat JDBC, BoneCP, Druid, and HikariCP—compares their features and performance, explores an even faster Scala async pool, discusses future middleware trends, and examines Sharding-JDBC's evolution toward a Database Mesh architecture.
The article examines how various JDBC connection pools such as Tomcat‑JDBC, Druid, c3p0, HikariCP, and BoneCP handle connection validation parameters like testOnBorrow, validationInterval, and idle checks, and provides recommendations for critical applications.
