当前位置：首页 > news >正文

Java 池化技术

news 2026/5/12 0:50:43

Java中的池化技术，这是一种通过重用对象来提升性能的重要技术。

1. 什么是池化技术

池化技术的核心思想是：将资源预先创建好，放在一个"池子"里，需要时从池中获取，用完后归还，而不是每次都创建新的。

2. 常见的池化技术

2.1 线程池

import java.util.concurrent.*; public class ThreadPoolExample { public static void main(String[] args) { // 创建固定大小的线程池 ExecutorService executor = Executors.newFixedThreadPool(5); // 提交任务 for (int i = 0; i < 10; i++) { executor.submit(() -> { System.out.println(Thread.currentThread().getName() + " 执行任务"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }); } // 关闭线程池 executor.shutdown(); } // 自定义线程池（推荐方式） public static ExecutorService createCustomThreadPool() { return new ThreadPoolExecutor( 5, // 核心线程数 10, // 最大线程数 60L, // 空闲线程存活时间 TimeUnit.SECONDS, // 时间单位 new LinkedBlockingQueue<>(100), // 任务队列 new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略 ); } }

2.2 数据库连接池

import com.zaxxer.hikari.HikariConfig; import com.zaxxer.hikari.HikariDataSource; import java.sql.*; public class ConnectionPoolExample { private static HikariDataSource dataSource; static { HikariConfig config = new HikariConfig(); config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb"); config.setUsername("root"); config.setPassword("password"); config.setMaximumPoolSize(10); config.setMinimumIdle(5); config.setConnectionTimeout(30000); dataSource = new HikariDataSource(config); } public static void main(String[] args) { // 使用连接 try (Connection conn = dataSource.getConnection(); PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users"); ResultSet rs = stmt.executeQuery()) { while (rs.next()) { System.out.println(rs.getString("username")); } } catch (SQLException e) { e.printStackTrace(); } } }

2.3 对象池（Apache Commons Pool）

import org.apache.commons.pool2.*; import org.apache.commons.pool2.impl.*; // 1. 定义可池化的对象 class ExpensiveObject { private String id; public ExpensiveObject() { System.out.println("创建新对象"); this.id = String.valueOf(System.currentTimeMillis()); } public void doSomething() { System.out.println("对象 " + id + " 执行操作"); } } // 2. 创建对象工厂 class ExpensiveObjectFactory extends BasePooledObjectFactory<ExpensiveObject> { @Override public ExpensiveObject create() { return new ExpensiveObject(); } @Override public PooledObject<ExpensiveObject> wrap(ExpensiveObject obj) { return new DefaultPooledObject<>(obj); } } // 3. 使用对象池 public class ObjectPoolExample { public static void main(String[] args) { GenericObjectPool<ExpensiveObject> pool = new GenericObjectPool<>(new ExpensiveObjectFactory()); pool.setMaxTotal(5); pool.setMaxIdle(3); pool.setMinIdle(1); try { // 从池中获取对象 ExpensiveObject obj1 = pool.borrowObject(); ExpensiveObject obj2 = pool.borrowObject(); obj1.doSomething(); obj2.doSomething(); // 归还对象 pool.returnObject(obj1); pool.returnObject(obj2); } catch (Exception e) { e.printStackTrace(); } } }

3. 池化技术的优势

3.1 性能提升

减少创建开销：避免频繁创建和销毁对象
降低GC压力：减少对象创建，降低垃圾回收频率
提高响应速度：对象已经创建好，直接使用

3.2 资源控制

public class ResourceControlExample { // 控制数据库连接数，避免耗尽数据库资源 @Configuration public class DataSourceConfig { @Bean public DataSource dataSource() { HikariConfig config = new HikariConfig(); config.setMaximumPoolSize(20); // 最大连接数 config.setMinimumIdle(5); // 最小空闲连接 config.setConnectionTimeout(30000); // 连接超时 return new HikariDataSource(config); } } }

4. 自定义简单对象池

import java.util.concurrent.*; import java.util.*; public class SimpleObjectPool<T> { private final BlockingQueue<T> pool; private final int maxSize; private final ObjectFactory<T> factory; private int createdCount = 0; public interface ObjectFactory<T> { T create(); } public SimpleObjectPool(int maxSize, ObjectFactory<T> factory) { this.maxSize = maxSize; this.factory = factory; this.pool = new LinkedBlockingQueue<>(maxSize); } public T borrow() throws InterruptedException { T obj = pool.poll(); if (obj != null) { return obj; } // 池为空，创建新对象（但不超过最大限制） synchronized (this) { if (createdCount < maxSize) { createdCount++; return factory.create(); } } // 等待归还 return pool.take(); } public void return_(T obj) { if (obj != null) { pool.offer(obj); } } // 使用示例 public static void main(String[] args) { SimpleObjectPool<StringBuilder> pool = new SimpleObjectPool<>( 3, StringBuilder::new ); try { StringBuilder sb = pool.borrow(); sb.append("Hello"); pool.return_(sb); } catch (InterruptedException e) { e.printStackTrace(); } } }

5. 池化配置调优

import org.apache.commons.pool2.impl.GenericObjectPoolConfig; public class PoolConfigOptimization { public static GenericObjectPoolConfig<?> createOptimizedConfig() { GenericObjectPoolConfig<?> config = new GenericObjectPoolConfig<>(); // 基本配置 config.setMaxTotal(50); // 最大对象数量 config.setMaxIdle(20); // 最大空闲对象 config.setMinIdle(5); // 最小空闲对象 // 行为配置 config.setBlockWhenExhausted(true); // 池耗尽时是否阻塞 config.setMaxWaitMillis(5000); // 最大等待时间 config.setTestOnBorrow(true); // 借用时测试有效性 config.setTestOnReturn(false); // 归还时测试有效性 config.setTestWhileIdle(true); // 空闲时测试有效性 // 维护配置 config.setTimeBetweenEvictionRunsMillis(30000); // 驱逐线程运行间隔 config.setMinEvictableIdleTimeMillis(60000); // 对象最小空闲时间 config.setSoftMinEvictableIdleTimeMillis(30000); // 软最小空闲时间 return config; } }

6. 注意事项

6.1 内存泄漏防范

public class PoolLeakPrevention { // 使用 try-with-resources 自动归还 public void safeUsePool(GenericObjectPool<Resource> pool) { try (PooledResourceWrapper wrapper = new PooledResourceWrapper(pool)) { Resource resource = wrapper.getResource(); // 使用资源 } // 自动归还 } // 包装类实现 AutoCloseable static class PooledResourceWrapper implements AutoCloseable { private final GenericObjectPool<Resource> pool; private final Resource resource; public PooledResourceWrapper(GenericObjectPool<Resource> pool) throws Exception { this.pool = pool; this.resource = pool.borrowObject(); } public Resource getResource() { return resource; } @Override public void close() { pool.returnObject(resource); } } }

6.2 监控和诊断

@Component public class PoolMonitor { private final HikariDataSource dataSource; public void printPoolStats() { HikariPoolMXBean poolMXBean = dataSource.getHikariPoolMXBean(); System.out.println("活跃连接数: " + poolMXBean.getActiveConnections()); System.out.println("空闲连接数: " + poolMXBean.getIdleConnections()); System.out.println("总连接数: " + poolMXBean.getTotalConnections()); System.out.println("等待线程数: " + poolMXBean.getThreadsAwaitingConnection()); } }