BestHub
Sign in
Tagged articles
196 articles
Page 2 of 2
Java Architect Essentials
Java Architect Essentials
Apr 16, 2023 · Databases

Alibaba Druid Connection Pool in Spring Boot: Concepts, Configuration, Monitoring and Customization

This article introduces Alibaba's Druid database connection pool, explains its core features and filters, shows how to add the Maven starter, configure properties and filters in Spring Boot, demonstrates the built‑in monitoring pages, slow‑SQL logging, Spring AOP integration, and provides methods to remove the default advertisement and retrieve monitoring data via code.

ConfigurationConnection PoolDruid
0 likes · 16 min read
Alibaba Druid Connection Pool in Spring Boot: Concepts, Configuration, Monitoring and Customization
37 Interactive Technology Team
37 Interactive Technology Team
Feb 10, 2023 · Backend Development

Analysis of Golang SQL Connection Pool Mechanism and Usage

The article examines Go’s database/sql connection pool implementation, showing how reusing connections cuts latency, explains idle/in‑use/closed state transitions, details configuration parameters such as MaxIdleConns and MaxOpenConns, demonstrates metric collection via Gorm DBStats for monitoring, and provides a stress‑test illustrating the impact of proper tuning.

Connection PoolGORMGolang
0 likes · 10 min read
Analysis of Golang SQL Connection Pool Mechanism and Usage
Code Ape Tech Column
Code Ape Tech Column
Dec 22, 2022 · Backend Development

Why Database Connection Pools Do Not Use IO Multiplexing (Java Interview Question)

The article explains why Java applications typically use traditional database connection pools instead of IO multiplexing, covering JDBC’s blocking design, session management, ecosystem maturity, and the complexity of integrating non‑blocking I/O with existing frameworks, while noting that a non‑blocking implementation is technically feasible.

BackendConnection PoolIO Multiplexing
0 likes · 9 min read
Why Database Connection Pools Do Not Use IO Multiplexing (Java Interview Question)
JD Cloud Developers
JD Cloud Developers
Dec 7, 2022 · Backend Development

Mastering Redis Integration in Rust: Singleton & Connection Pool Guide

This article explains how to integrate Redis into a Rust backend by defining resource structs, wrapping the client with enums, implementing a connection pool using r2d2, creating a global singleton with once_cell, and providing example code for querying and storing data.

Connection PoolRustbackend-development
0 likes · 8 min read
Mastering Redis Integration in Rust: Singleton & Connection Pool Guide
Code Ape Tech Column
Code Ape Tech Column
Oct 26, 2022 · Databases

In‑Depth Analysis of Druid Connection‑Pool Lifecycle and Internal Processes

This article provides a comprehensive walkthrough of Druid's connection‑pool architecture, detailing the initialization, acquisition, validation, eviction, and recycling of connections, while explaining key configuration options, thread‑safety mechanisms, and performance considerations for Java database applications.

Connection PoolDruiddatabase
0 likes · 23 min read
In‑Depth Analysis of Druid Connection‑Pool Lifecycle and Internal Processes
Su San Talks Tech
Su San Talks Tech
Sep 28, 2022 · Databases

Why MySQL Queries Slow Down and How to Speed Them Up

This article explains the common reasons MySQL queries become sluggish—beyond missing indexes—including connection limits, buffer pool size, and query cache, and provides practical solutions such as profiling, adjusting connection pools, tuning InnoDB settings, and using force index.

Connection Poolbuffer poolindexing
0 likes · 16 min read
Why MySQL Queries Slow Down and How to Speed Them Up
Top Architect
Top Architect
Aug 29, 2022 · Mobile Development

Understanding OkHttp: Request Flow, Dispatcher, Interceptors, Connection Reuse, and Design Patterns

This article provides a comprehensive overview of OkHttp, covering its overall request process, the role of the dispatcher, how application and network interceptors work, TCP connection reuse via the connection pool, idle‑connection cleanup, key advantages, and the design patterns employed in the framework.

AndroidConnection PoolDesign Patterns
0 likes · 15 min read
Understanding OkHttp: Request Flow, Dispatcher, Interceptors, Connection Reuse, and Design Patterns
Java High-Performance Architecture
Java High-Performance Architecture
Aug 12, 2022 · Backend Development

Mastering Java Connection Pools: From Commons Pool to HikariCP Performance Secrets

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.

Commons-PoolConnection PoolHikariCP
0 likes · 15 min read
Mastering Java Connection Pools: From Commons Pool to HikariCP Performance Secrets
FunTester
FunTester
Jul 18, 2022 · Databases

Why MySQL’s MysqlConnectionPoolDataSource Isn’t a Real Connection Pool (And How to Use It)

The article examines the MySQL class com.mysql.cj.jdbc.MysqlConnectionPoolDataSource, revealing that despite its name it creates new connections each request and only recycles idle ones, provides a practical Groovy example, highlights pitfalls such as duplicate setURL methods, and concludes it’s unsuitable as a true pool for testing.

Connection PoolGroovyPerformance Testing
0 likes · 5 min read
Why MySQL’s MysqlConnectionPoolDataSource Isn’t a Real Connection Pool (And How to Use It)
dbaplus Community
dbaplus Community
Jul 11, 2022 · Databases

Why Is MySQL Query Slow? Hidden Factors Beyond Indexes and How to Fix Them

This article explains why MySQL queries can become sluggish, covering the full query execution flow, profiling techniques, index pitfalls, connection‑pool limits, buffer‑pool sizing, and additional performance tricks, while providing concrete commands and code examples for each optimization step.

Connection PoolIndex OptimizationProfiling
0 likes · 16 min read
Why Is MySQL Query Slow? Hidden Factors Beyond Indexes and How to Fix Them
Top Architect
Top Architect
Jul 1, 2022 · Databases

Analyzing the Time Cost of Establishing MySQL Database Connections in Java Web Applications

This article examines how a MySQL connection is created from a Java web application, breaking down the TCP handshake, authentication, and variable‑setting steps with Wireshark captures, measuring latency, and demonstrating why connection pooling is essential to avoid hundreds of milliseconds of overhead per request.

Connection PoolDatabase ConnectionTCP
0 likes · 7 min read
Analyzing the Time Cost of Establishing MySQL Database Connections in Java Web Applications
FunTester
FunTester
Jun 27, 2022 · Backend Development

Implementing a Custom MySQL Connection Pool with Apache Commons Pool2 in Java

The article explains how to build a reusable MySQL connection pool in Java using Apache Commons Pool2, detailing the creation of a poolable object, a factory class, the pool configuration, and a simple API wrapper for borrowing and returning connections while providing full source code examples.

Connection Poolcommons-pool2java
0 likes · 7 min read
Implementing a Custom MySQL Connection Pool with Apache Commons Pool2 in Java
Baidu Geek Talk
Baidu Geek Talk
Jun 22, 2022 · Databases

Analyzing Go SQL Connection Pool Resource Release and Transaction Management

The article explains how Go's database/sql pool retains connections until Rows, Stmt, or Tx objects are explicitly closed or a timeout context is cancelled, demonstrates experiments showing blocked goroutines when resources aren't released, and offers practical guidelines—using QueryContext with timeouts, deferring Close/Cancel, and always committing or rolling back transactions—to prevent pool exhaustion and improve MySQL reliability.

Connection PoolGodatabase
0 likes · 19 min read
Analyzing Go SQL Connection Pool Resource Release and Transaction Management
Su San Talks Tech
Su San Talks Tech
Jun 6, 2022 · Databases

Why Is MySQL Query Slow? Hidden Factors Beyond Indexes and How to Fix Them

This article explores the various reasons MySQL queries become slow—including index misuse, insufficient connection pools, small InnoDB buffer pools, and query cache limitations—while providing practical solutions such as optimizing indexes, adjusting max_connections, enlarging buffer pools, and configuring connection pools for better performance.

Connection PoolIndex OptimizationInnoDB
0 likes · 16 min read
Why Is MySQL Query Slow? Hidden Factors Beyond Indexes and How to Fix Them
ITPUB
ITPUB
Apr 29, 2022 · Databases

How to Fix MySQL 500 Errors by Tuning wait_timeout and autoReconnect

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.

BackendConnection PoolHikariCP
0 likes · 7 min read
How to Fix MySQL 500 Errors by Tuning wait_timeout and autoReconnect
Open Source Linux
Open Source Linux
Apr 25, 2022 · Backend Development

Master TCP/UDP, Sockets & Connection Pools in Node.js – From Basics to Advanced

This article walks developers through the fundamentals of the OSI model, TCP three‑way handshake and UDP characteristics, explains socket concepts, demonstrates Node.js server and client implementations with heartbeats and custom protocols, and details how to build and use a socket connection pool with the generic‑pool library.

Connection PoolNode.jsSocket
0 likes · 39 min read
Master TCP/UDP, Sockets & Connection Pools in Node.js – From Basics to Advanced
MaGe Linux Operations
MaGe Linux Operations
Apr 4, 2022 · Backend Development

Mastering gRPC Connection Pools: Design Principles and Tuning Tips

This article explains how to design a gRPC connection pool, covering scaling rules, idle‑connection timeout and keep‑alive, pool‑full handling, core gRPC features, and practical tuning parameters to achieve high performance in high‑concurrency backend services.

BackendConnection PoolTuning
0 likes · 13 min read
Mastering gRPC Connection Pools: Design Principles and Tuning Tips
NiuNiu MaTe
NiuNiu MaTe
Mar 30, 2022 · Databases

Why Is MySQL Query Slow? Hidden Factors and Proven Speed‑Up Tricks

This article explains why MySQL queries can become sluggish beyond missing indexes, covering the full query execution flow, profiling tools, index pitfalls, connection‑pool limits, InnoDB buffer‑pool sizing, and practical steps to diagnose and accelerate database performance.

Connection Poolbuffer poolindexing
0 likes · 16 min read
Why Is MySQL Query Slow? Hidden Factors and Proven Speed‑Up Tricks
Code Ape Tech Column
Code Ape Tech Column
Mar 17, 2022 · Databases

Understanding the Druid Connection Pool Lifecycle and Management

This article provides a comprehensive walkthrough of Druid's connection pool lifecycle, detailing how getConnection initiates the process, the role of initialization, filter chains, connection validation, thread‑blocking strategies, and the various guardian threads that add, evict, and recycle connections to ensure performance and stability.

Connection PoolDruiddatabase
0 likes · 24 min read
Understanding the Druid Connection Pool Lifecycle and Management
IT Services Circle
IT Services Circle
Mar 15, 2022 · Backend Development

Understanding Pooling Techniques: Thread Pools, Memory Pools, Database Connection Pools, and HttpClient Pools in Java

This article explains the concept of pooling technology, its advantages, and its practical applications in Java—including thread pools, memory pools, database connection pools, and HttpClient connection pools—while highlighting how these techniques improve performance, resource utilization, and system stability.

Connection PoolResource Managementjava
0 likes · 10 min read
Understanding Pooling Techniques: Thread Pools, Memory Pools, Database Connection Pools, and HttpClient Pools in Java
IT Services Circle
IT Services Circle
Feb 20, 2022 · Databases

Understanding and Optimizing Database Connection Pools with Go and MySQL

This article explains how improper use of database connection pools can cause service timeouts, demonstrates with Go and MySQL how to configure and test connection pooling, shows performance improvements through reuse, and encourages developers to implement their own pools for better efficiency.

Connection PoolGolang
0 likes · 8 min read
Understanding and Optimizing Database Connection Pools with Go and MySQL
Top Architect
Top Architect
Feb 8, 2022 · Backend Development

Why Database Connection Pools Do Not Use IO Multiplexing

The article explains why traditional Java database connection pools rely on blocking I/O instead of IO multiplexing, covering JDBC's design, session management, resource constraints, and the practical challenges of adopting non‑blocking approaches in mainstream backend systems.

Connection PoolJDBCdatabase
0 likes · 9 min read
Why Database Connection Pools Do Not Use IO Multiplexing
FunTester
FunTester
Jan 24, 2022 · Backend Development

Custom Java DNS Resolver with Apache HttpClient: InMemoryDnsResolver and SystemDefaultDnsResolver

This article demonstrates how to implement custom DNS resolvers in Java using Apache HttpClient's InMemoryDnsResolver and SystemDefaultDnsResolver classes, provides sample code for each, shows integration with a connection pool manager, and includes a simple test to verify hostname resolution.

Apache HttpClientConnection PoolCustom Resolver
0 likes · 7 min read
Custom Java DNS Resolver with Apache HttpClient: InMemoryDnsResolver and SystemDefaultDnsResolver
Programmer DD
Programmer DD
Jan 21, 2022 · Databases

Why Java DB Connection Pools Skip IO Multiplexing (And What It Means)

This article explains why Java database connection pools typically use blocking I/O and connection pooling instead of IO multiplexing, covering JDBC's design, session management, ecosystem constraints, and the trade‑offs between performance and code complexity.

Connection PoolIO MultiplexingJDBC
0 likes · 8 min read
Why Java DB Connection Pools Skip IO Multiplexing (And What It Means)
Architect's Tech Stack
Architect's Tech Stack
Jan 11, 2022 · Backend Development

Diagnosing Redis Connection Pool Blocking in a Spring Boot Application

The article details a week‑long investigation of unresponsive APIs in a sandbox environment, tracing the root cause to Redis connection pool blocking in a Spring Boot service, and presents step‑by‑step debugging, code analysis, configuration fixes, and best‑practice recommendations for proper Redis usage.

ArthasConnection PoolJedis
0 likes · 9 min read
Diagnosing Redis Connection Pool Blocking in a Spring Boot Application
Top Architect
Top Architect
Jan 2, 2022 · Backend Development

Debugging Redis Connection Pool Blocking Issues in a Spring Backend Application

The article details a step‑by‑step investigation of a Spring‑based backend where API requests hung due to Redis connection pool misconfiguration, showing how thread dumps, jstack, and Arthas were used to pinpoint blocking in Jedis pool acquisition, and provides corrected configuration and proper connection handling recommendations.

Connection PoolJedisdebugging
0 likes · 9 min read
Debugging Redis Connection Pool Blocking Issues in a Spring Backend Application
New Oriental Technology
New Oriental Technology
Dec 29, 2021 · Databases

Understanding HikariCP: Architecture, Core Components, and Usage

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.

Connection PoolHikariCPSpring Boot
0 likes · 21 min read
Understanding HikariCP: Architecture, Core Components, and Usage
政采云技术
政采云技术
Oct 28, 2021 · Backend Development

HikariCP Overview (Part 1): Initialization, Core Components, Monitoring and Configuration

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.

ConfigurationConnection PoolHikariCP
0 likes · 14 min read
HikariCP Overview (Part 1): Initialization, Core Components, Monitoring and Configuration
dbaplus Community
dbaplus Community
Oct 24, 2021 · Backend Development

Fixing 18B Daily Dubbo Calls: Solving Redis Connection Pool Exhaustion

When a Dubbo interface handling 18 billion daily requests began failing due to thread‑pool exhaustion, a systematic investigation uncovered traffic spikes, Redis request overload, and mis‑configured connection‑pool parameters, leading to a series of targeted fixes—including timeout adjustments, Redis scaling, and pool‑parameter tuning—that restored stability and dramatically reduced error rates.

Connection PoolDubbojava
0 likes · 16 min read
Fixing 18B Daily Dubbo Calls: Solving Redis Connection Pool Exhaustion
FunTester
FunTester
Sep 2, 2021 · Backend Development

How to Build a Robust Redis Connection Pool Wrapper in Java for Performance Testing

This article walks through creating a reusable Redis connection‑pool manager and a functional wrapper class in Java, explaining pooling concepts, resource recycling, and providing ready‑to‑use methods for common Redis commands to support efficient performance testing with the FunTester framework.

Connection PoolPerformance Testingbackend-development
0 likes · 18 min read
How to Build a Robust Redis Connection Pool Wrapper in Java for Performance Testing
vivo Internet Technology
vivo Internet Technology
Jul 7, 2021 · Databases

Lettuce vs Jedis: Features, Usage, and Comparison of Java Redis Clients

Lettuce, a thread‑safe, Netty‑based Java Redis client supporting synchronous, asynchronous, reactive, Cluster, Sentinel, pipelining and custom codecs, outperforms Jedis’s non‑thread‑safe pooled connections by reducing resource consumption, simplifying Spring integration, and offering advanced features like read‑write splitting, topology refresh, and optional pooling for high‑throughput applications.

AsyncConnection PoolJedis
0 likes · 15 min read
Lettuce vs Jedis: Features, Usage, and Comparison of Java Redis Clients
Programmer DD
Programmer DD
Jun 23, 2021 · Backend Development

Why Spring Boot APIs Hang: Debugging a Redis Connection Pool Deadlock

A week‑long API freeze in a sandbox environment was traced to Redis connection pool deadlocks caused by missing pool configuration and improper connection handling, and the article walks through the diagnosis with top, jstack, Arthas, and the code changes needed to fix it.

ArthasConnection PoolJedis
0 likes · 9 min read
Why Spring Boot APIs Hang: Debugging a Redis Connection Pool Deadlock
vivo Internet Technology
vivo Internet Technology
Jun 16, 2021 · Backend Development

Troubleshooting Dubbo Thread Pool Exhaustion: A Redis Performance Optimization Case Study

The case study details how a high‑traffic Dubbo service handling 1.8 billion daily requests suffered periodic circuit‑breaks due to thread‑pool exhaustion, traced to a cache‑bypass bug, Redis setex spikes, and an improperly warmed commons‑pool2 connection pool, and resolved by fixing the bug, scaling Redis, and tuning or downgrading the pool configuration to enable pre‑warming via minEvictableIdleTimeMillis.

Circuit BreakingConnection PoolDubbo
0 likes · 13 min read
Troubleshooting Dubbo Thread Pool Exhaustion: A Redis Performance Optimization Case Study
IT Xianyu
IT Xianyu
Jun 16, 2021 · Databases

Understanding Database Connection Pools vs. ThreadLocal in Java

This article explains the fundamental differences between database connection pools and ThreadLocal‑cached connections in Java, illustrating how connection pools improve performance while ThreadLocal enables sharing a single connection across methods within the same thread for consistent transaction control, and discusses practical usage patterns.

Connection PoolThreadLocalbackend-development
0 likes · 7 min read
Understanding Database Connection Pools vs. ThreadLocal in Java
Java Backend Technology
Java Backend Technology
Jun 12, 2021 · Databases

Why My Spring API Stalled: Debugging Redis Connection Pool Blocking

A Spring‑based service repeatedly hung because Redis connections were never returned to the pool, leading to thread starvation; the article walks through the investigation using top, jstack, Arthas, and code analysis, then shows the proper way to use RedisCallback and release connections to prevent the deadlock.

Connection PoolJedisdebugging
0 likes · 9 min read
Why My Spring API Stalled: Debugging Redis Connection Pool Blocking
Java Interview Crash Guide
Java Interview Crash Guide
Jun 8, 2021 · Backend Development

Why Did Our Spring API Hang? Uncovering Redis Connection Pool Blocking

After a week of intermittent API hangs in an internal sandbox, we traced the issue to Redis connection pool blocking caused by missing max‑wait configuration, leading to threads waiting indefinitely; by adjusting Jedis pool settings, using proper connection release, and avoiding unsupported commands, the deadlock was resolved.

Connection PoolJedisdebugging
0 likes · 9 min read
Why Did Our Spring API Hang? Uncovering Redis Connection Pool Blocking
Youzan Coder
Youzan Coder
May 31, 2021 · Backend Development

16 TCP Network Programming Best Practices for Building Robust Applications

The article presents sixteen practical TCP network‑programming best practices—from setting SO_REUSEADDR and defining port standards to using application‑layer heartbeats, exponential backoff, connection limits, client‑side load balancing, periodic DNS refresh, optimal buffer sizing, configurable timeouts, proper connection‑pool sizing, and comprehensive metrics—to help developers build stable, reliable applications.

Connection PoolLinux TCPNetwork Monitoring
0 likes · 28 min read
16 TCP Network Programming Best Practices for Building Robust Applications
Architect's Tech Stack
Architect's Tech Stack
May 23, 2021 · Databases

Understanding the Difference Between Database Connection Pools and ThreadLocal-Managed Connections

This article explains how database connection pools cache and reuse connections for performance while ThreadLocal can share a single connection within the same thread to enable cross‑method transaction control, highlighting their fundamental differences, usage scenarios, and practical code examples.

Connection PoolThreadLocaldatabase
0 likes · 6 min read
Understanding the Difference Between Database Connection Pools and ThreadLocal-Managed Connections
macrozheng
macrozheng
May 17, 2021 · Databases

Which Java Connection Pool Wins? Druid vs C3P0 vs DBCP Performance Tested

This article introduces the importance of database connections, compares three popular Java connection pools (DBCP, C3P0, Druid) with code examples, runs performance tests inserting 100 k and 1 M rows on MySQL, Oracle and PostgreSQL, and concludes with recommendations on the most stable pool and optimal databases.

Connection PoolDruidPerformance Test
0 likes · 11 min read
Which Java Connection Pool Wins? Druid vs C3P0 vs DBCP Performance Tested
Java Backend Technology
Java Backend Technology
May 16, 2021 · Backend Development

Why ThreadLocal and Connection Pools Differ: Master Transaction Management in Java

This article explains the fundamental differences between database connection pools and ThreadLocal in Java, showing how pools improve performance while ThreadLocal enables sharing a single connection across a thread for seamless transaction control, and clarifies common misconceptions with code examples and practical insights.

Connection PoolThreadLocaljava
0 likes · 6 min read
Why ThreadLocal and Connection Pools Differ: Master Transaction Management in Java
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 7, 2021 · Databases

Resolving MySQL wait_timeout Issues with Druid Connection Pool Configuration

This article analyzes the root causes of MySQL 'wait_timeout' related exceptions in a backend system using MHA read/write separation, explains how oversized connection pool timeout settings and MySQL wait_timeout lead to idle connections being closed, and provides practical Druid configuration adjustments and alternative solutions to eliminate the errors.

BackendConnection PoolDruid
0 likes · 7 min read
Resolving MySQL wait_timeout Issues with Druid Connection Pool Configuration
Laravel Tech Community
Laravel Tech Community
Feb 25, 2021 · Databases

Python Database Operations: Using DB-API, PyMySQL, and Connection Pools

This article introduces Python's DB-API for interacting with various databases, explains how to use PyMySQL and MySQLdb for MySQL operations, demonstrates basic CRUD examples, shows techniques to prevent SQL injection, and presents connection pooling solutions with DBUtils for multi‑threaded applications.

Connection PoolDB-APISQL injection
0 likes · 14 min read
Python Database Operations: Using DB-API, PyMySQL, and Connection Pools
Code Ape Tech Column
Code Ape Tech Column
Feb 24, 2021 · Databases

Understanding HikariCP Connection Pool Sizing: Principles, Experiments, and Practical Guidelines

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.

Connection PoolDatabase PerformanceHikariCP
0 likes · 9 min read
Understanding HikariCP Connection Pool Sizing: Principles, Experiments, and Practical Guidelines
NiuNiu MaTe
NiuNiu MaTe
Feb 8, 2021 · Databases

Estimating MySQL TCP Connections for 100 Writes/sec Over 5 Seconds

This article analyzes how many TCP connections MySQL will open when writing data at 100 rows per second for five seconds, examining MySQL processing capacity and connection‑pool configuration to illustrate the key factors that affect connection count.

Connection PoolTCP connectionsmysql
0 likes · 8 min read
Estimating MySQL TCP Connections for 100 Writes/sec Over 5 Seconds
Sohu Tech Products
Sohu Tech Products
Jan 20, 2021 · Mobile Development

OkOne: An Unintrusive OkHttp Performance Optimization Framework for Android

This article introduces OkOne, a lightweight framework built on OkHttp that centralizes client management to reduce redundant instances, demonstrates step‑by‑step integration, shows performance gains through instance and connection reuse, and explores advanced features such as pre‑connect and detailed internal mechanisms.

Connection PoolOkHttpOkOne
0 likes · 13 min read
OkOne: An Unintrusive OkHttp Performance Optimization Framework for Android
MaGe Linux Operations
MaGe Linux Operations
Sep 29, 2020 · Databases

Master Python Database Access: From DB‑API to Connection Pools

This article introduces Python's DB‑API for interacting with various databases, explains how to use PyMySQL and SQLAlchemy for MySQL, demonstrates basic CRUD operations, safeguards against SQL injection, and shows how to implement thread‑safe connection pools with DBUtils for scalable backend applications.

Connection PoolDBAPIDBUtils
0 likes · 17 min read
Master Python Database Access: From DB‑API to Connection Pools
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 29, 2020 · Backend Development

Analyzing and Fixing Netty FixedChannelPool Connection Timeout Bugs

This article investigates a recurring Netty connection‑pool timeout bug caused by missing acquire‑timeout handling, explains the internal workings of FixedChannelPool's acquire and release mechanisms, and presents a corrected implementation that configures an AcquireTimeoutAction, adjusts pool sizes, and removes premature timeout calls.

Connection PoolFixedChannelPoolNetty
0 likes · 29 min read
Analyzing and Fixing Netty FixedChannelPool Connection Timeout Bugs
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 15, 2020 · Databases

Resolving MySQL wait_timeout and JDBC Connection‑Pool Exceptions with Druid Configuration

This article analyses the root cause of generic "exception" errors during article publishing caused by mismatched MySQL wait_timeout and Druid JDBC pool settings, explains the impact of these parameters, and provides step‑by‑step configuration adjustments and alternative solutions to stabilise the backend database connection pool.

Connection PoolDatabase OptimizationDruid
0 likes · 6 min read
Resolving MySQL wait_timeout and JDBC Connection‑Pool Exceptions with Druid Configuration
Sohu Tech Products
Sohu Tech Products
Aug 26, 2020 · Operations

Production Environment Optimization: Deep Dive into GC, Tracing, and Connection‑Pool Issues

This article walks through a real‑world production incident involving intermittent interface timeouts, demonstrates how tracing with SkyWalking and log analysis revealed a downstream service problem, explores GC log diagnostics, uncovers misconfigured c3p0 connection‑pool settings, and shares practical lessons for Java backend performance tuning.

Connection Poolgcjava
0 likes · 21 min read
Production Environment Optimization: Deep Dive into GC, Tracing, and Connection‑Pool Issues
ITPUB
ITPUB
Aug 10, 2020 · Databases

Why Smaller Database Connection Pools Boost Performance: Real-World Test Insights

A detailed analysis shows that reducing the size of a database connection pool can dramatically lower request latency and improve throughput, with real benchmark data from Oracle and PostgreSQL illustrating how CPU, disk, and network constraints dictate the optimal pool size.

Connection PoolScalabilitybenchmark
0 likes · 10 min read
Why Smaller Database Connection Pools Boost Performance: Real-World Test Insights
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 2, 2020 · Backend Development

Understanding Pooling Techniques: Thread Pools, Memory Pools, Connection Pools, and HttpClient Pools in Java

This article explains the concept of pooling technology in Java, illustrating its benefits through real‑world analogies, detailing thread pools, memory pools, database connection pools, and HttpClient pools, and provides a performance comparison between raw threads and thread pools using a Java benchmark.

BackendConnection Pooljava
0 likes · 11 min read
Understanding Pooling Techniques: Thread Pools, Memory Pools, Connection Pools, and HttpClient Pools in Java
Programmer DD
Programmer DD
May 20, 2020 · Backend Development

Why Does Druid Throw “Connection Holder Is Null” and How to Fix It?

This article examines recurring “connection holder is null” errors in Druid’s connection pool, explains how the holder is assigned and cleared, analyzes two real‑world cases—long‑running transactions and killed connections—and offers practical configuration recommendations to prevent the issue.

Connection PoolDruidException Handling
0 likes · 7 min read
Why Does Druid Throw “Connection Holder Is Null” and How to Fix It?
Youzan Coder
Youzan Coder
Apr 15, 2020 · Databases

Optimizing Druid Connection Pool: Practical Configurations and Tuning Guide

This article explains how to size and tune Druid's connection pool for high‑traffic Java applications, covering pool‑size formulas, timeout settings, keep‑alive behavior, essential XML properties, and version recommendations to prevent misleading SQL latency and improve overall database stability.

Connection PoolDruiddatabase
0 likes · 10 min read
Optimizing Druid Connection Pool: Practical Configurations and Tuning Guide
Architects Research Society
Architects Research Society
Mar 20, 2020 · Operations

Envoy Health Checks: Active, Passive, Filters, and Connection‑Pool Interaction

Envoy provides active and passive health checks—including HTTP, L3/L4, and Redis types—configurable intervals and failure thresholds, along with a health‑check filter that can bypass, forward, or cache requests, and detailed connection‑pool handling for HTTP/1.1 and HTTP/2 to ensure reliable service routing.

Connection PoolEnvoyService Mesh
0 likes · 7 min read
Envoy Health Checks: Active, Passive, Filters, and Connection‑Pool Interaction
Liulishuo Tech Team
Liulishuo Tech Team
Mar 17, 2020 · Backend Development

High‑Performance Image Generation Service Using Puppeteer with Connection Pool and Parameter Optimization

This article describes how a content‑heavy company built a scalable, high‑quality image generation service for its app by leveraging Puppeteer, a custom connection‑pool implementation, CDN caching, launch‑argument tuning, and performance monitoring to achieve low latency and high throughput.

Connection PoolImage RenderingNode.js
0 likes · 8 min read
High‑Performance Image Generation Service Using Puppeteer with Connection Pool and Parameter Optimization
FunTester
FunTester
Jan 24, 2020 · Backend Development

How to Tag Every API Request with RequestID for Precise Performance Testing

This article explains how to implement request‑ID tagging for each API call in a Java performance‑testing framework, describes the updated MarkRequest implementations, shows how to configure connection‑pool timeouts and retries, and provides full source code examples for both header‑based and string‑based markers.

Code ExampleConnection PoolHTTP
0 likes · 6 min read
How to Tag Every API Request with RequestID for Precise Performance Testing
Programmer DD
Programmer DD
Jan 6, 2020 · Backend Development

How a Misconfigured HttpClient Connection Pool Triggered a System Avalanche

An engineer recounts how a high‑traffic promotion system suffered port exhaustion and thread‑pool overload due to a default max‑connections‑per‑host setting of two, leading to CPU spikes, process crashes, and a cascading failure, and outlines the investigation steps and preventive measures.

BackendConnection PoolHttpClient
0 likes · 10 min read
How a Misconfigured HttpClient Connection Pool Triggered a System Avalanche
ITPUB
ITPUB
Jan 5, 2020 · Backend Development

Why My HttpClient Connection Pool Crashed the System: A Thread Exhaustion Study

The author describes how a high‑traffic promotion system using HttpClient suffered massive thread and port exhaustion due to misconfigured connection‑pool parameters, details the investigation steps—including monitoring, jstack analysis, and source code review—and outlines corrective measures and preventive testing strategies.

Connection PoolHttpClientThread Exhaustion
0 likes · 10 min read
Why My HttpClient Connection Pool Crashed the System: A Thread Exhaustion Study
Qunar Tech Salon
Qunar Tech Salon
Nov 8, 2019 · Backend Development

Analyzing and Resolving TCP CLOSE_WAIT Issues in Java HTTP Client with Apache HttpClient

This article investigates the root causes of excessive TCP CLOSE_WAIT connections in a Java service, explains TCP state transitions, demonstrates packet capture analysis, and details how improper use of Apache HttpClient and its connection pool leads to lingering sockets, offering concrete debugging steps and configuration fixes.

CLOSE_WAITConnection PoolHttpClient
0 likes · 32 min read
Analyzing and Resolving TCP CLOSE_WAIT Issues in Java HTTP Client with Apache HttpClient
dbaplus Community
dbaplus Community
Nov 3, 2019 · Databases

Mastering HikariCP: 7 Essential Metrics and Real-World Troubleshooting

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.

Connection PoolHikariCPjava
0 likes · 34 min read
Mastering HikariCP: 7 Essential Metrics and Real-World Troubleshooting
FunTester
FunTester
Aug 15, 2019 · Backend Development

Boost Your Mac Load Test: Tuning sysctl and HttpClient for 20k+ Connections

This guide shares practical steps to overcome TIME_WAIT port exhaustion on macOS and optimize Apache HttpClient settings for high‑concurrency load testing, including sysctl tweaks for maximum file descriptors, port range adjustments, connection‑pool parameters, timeout configurations, and a custom connection‑recycling thread, enabling over 20 k concurrent requests without bottlenecks.

Connection PoolHttpClientLoad Testing
0 likes · 5 min read
Boost Your Mac Load Test: Tuning sysctl and HttpClient for 20k+ Connections
Youzan Coder
Youzan Coder
Jun 26, 2019 · Databases

Avoid Common Druid Connection Pool Pitfalls: Key Configurations Explained

This article examines Druid 1.1.5 connection‑pool settings—maxWait, connectionProperties, keepAlive, maxActive—illustrates real‑world cases of misconfiguration, provides recommended values, and shares a step‑by‑step investigation of a DB slow‑query incident to help engineers prevent performance and stability issues.

ConfigurationConnection PoolDruid
0 likes · 12 min read
Avoid Common Druid Connection Pool Pitfalls: Key Configurations Explained
Qunar Tech Salon
Qunar Tech Salon
Apr 24, 2019 · Backend Development

Resolving HTTP ConnectionPoolTimeoutException and CLOSE_WAIT Issues in Java Applications

This article analyzes a production Java service that repeatedly hit org.apache.http.conn.ConnectionPoolTimeoutException due to exhausted HttpClient connection pools, explains how CLOSE_WAIT sockets are created when responses are not closed, and provides step‑by‑step code fixes and Tomcat configuration tweaks to eliminate the problem.

Connection PoolHttpClientTomcat
0 likes · 11 min read
Resolving HTTP ConnectionPoolTimeoutException and CLOSE_WAIT Issues in Java Applications
Java Captain
Java Captain
Aug 28, 2018 · Databases

Design and Implementation of a Mini Database Connection Pool

This article explains the concept, design considerations, and step‑by‑step implementation of a lightweight database connection pool in Java, covering its core components, thread‑safe management, configuration handling, and a test demonstration of its functionality.

Connection PoolDesign Patternsdatabase
0 likes · 5 min read
Design and Implementation of a Mini Database Connection Pool
Programmer DD
Programmer DD
Mar 17, 2018 · Backend Development

How to Optimize JedisPool Settings for High‑Performance Redis Connections

This article explains how to correctly configure JedisPool and its underlying GenericObjectPoolConfig, provides Maven dependency details, demonstrates pool initialization and usage patterns, and offers practical recommendations for maxTotal, maxIdle, minIdle, idle monitoring, and warm‑up to ensure stable and efficient Redis operations in Java applications.

ConfigurationConnection PoolJedis
0 likes · 9 min read
How to Optimize JedisPool Settings for High‑Performance Redis Connections
Java Captain
Java Captain
Jan 6, 2018 · Backend Development

Database Connection Pooling in Java: Concepts, Implementation, and Configuration

This article explains why creating a database connection for each request is inefficient, introduces the concept and configuration of connection pools, provides a custom Java DataSource implementation, and demonstrates the use of popular open‑source pools such as DBCP, C3P0, and Tomcat JNDI with complete code examples.

Connection PoolJDBCJNDI
0 likes · 24 min read
Database Connection Pooling in Java: Concepts, Implementation, and Configuration
Java Backend Technology
Java Backend Technology
Jun 25, 2017 · Backend Development

Mastering Druid: Configure Connection Pool, Encrypt Passwords, and Monitor SQL

This guide explains Druid’s key features—including a high‑performance connection pool, SQL monitoring, password encryption, and customizable JDBC filters—and provides step‑by‑step instructions for configuring the pool, creating a custom DruidPasswordCallback, generating RSA keys, encrypting passwords, and integrating the setup into Spring.

Connection PoolDruidPassword Encryption
0 likes · 5 min read
Mastering Druid: Configure Connection Pool, Encrypt Passwords, and Monitor SQL
ITPUB
ITPUB
Apr 14, 2017 · Databases

Essential MySQL Optimization Techniques for High-Performance Databases

This guide outlines practical MySQL optimization strategies—including table schema design, index creation, SQL tuning, connection‑pool configuration, and historical data archiving—to help developers maintain fast, scalable databases as data volume grows.

Connection PoolDatabase OptimizationSQL Tuning
0 likes · 14 min read
Essential MySQL Optimization Techniques for High-Performance Databases
转转QA
转转QA
Feb 13, 2017 · Databases

Redis Connection Pool Saturation: A Debugging Tale

A developer recounts how a Redis connection pool overflow across dozens of clusters was traced to a single misbehaving service, diagnosed with netstat and ps commands, and resolved by adjusting configuration and stopping the offending process, illustrating practical troubleshooting of connection limits.

Connection PoolOperationsmonitoring
0 likes · 4 min read
Redis Connection Pool Saturation: A Debugging Tale
ITPUB
ITPUB
Sep 23, 2016 · Databases

Master MySQL Performance: Practical Table, Index, and Connection Pool Optimizations

This article presents practical MySQL optimization techniques covering table schema design, character set choices, primary key strategies, field definitions, index creation, SQL query tuning, pagination tricks, join handling, connection‑pool parameter tuning, and historical data archiving for large‑scale databases.

Connection PoolDatabase OptimizationSQL Performance
0 likes · 13 min read
Master MySQL Performance: Practical Table, Index, and Connection Pool Optimizations
Java High-Performance Architecture
Java High-Performance Architecture
Aug 5, 2016 · Databases

5 Essential Redis Tips from Heroku to Boost Performance

Heroku shares five practical Redis recommendations—including using connection pools, naming clients, selecting key eviction policies, avoiding the KEYS command, and configuring connection timeouts—to improve performance, manage resources, and simplify troubleshooting in production environments.

Client NamingConnection PoolKey Eviction
0 likes · 4 min read
5 Essential Redis Tips from Heroku to Boost Performance
dbaplus Community
dbaplus Community
Mar 28, 2016 · Backend Development

How to Keep Cache and Database Consistent: Invalidate First, Serialize Access

This article explains why cache and database can become inconsistent in distributed systems, why the "invalidate‑cache‑then‑write‑DB" rule is preferred, and presents practical serialization techniques—modifying DB and service connection pools—to guarantee per‑key sequential execution while maintaining availability and load balance.

Backend ArchitectureCacheConnection Pool
0 likes · 11 min read
How to Keep Cache and Database Consistent: Invalidate First, Serialize Access
21CTO
21CTO
Sep 25, 2015 · Backend Development

Building a High‑Performance Asynchronous MySQL Proxy with Swoole

This article explains how to create an asynchronous MySQL proxy server using the Swoole extension, detailing connection pooling, idle/busy management, request queuing, and providing a complete PHP implementation that reduces MySQL load and network overhead for PHP applications.

AsynchronousConnection PoolPHP
0 likes · 6 min read
Building a High‑Performance Asynchronous MySQL Proxy with Swoole