架构之对象池
引言
在高并发系统中，对象的频繁创建与销毁不仅会带来巨大的性能开销，更可能导致内存抖动和垃圾回收压力。对象池技术正是为解决这一痛点而生，它通过预创建、统一管理的策略，将零散的对象操作转化为高效的池化操作，从而显著提升系统性能。
本文将深入探讨对象池的黄金法则，从原理到实现，从应用到优化，全面解析这一高性能编程的核心技术。
对象池的核心理念
什么是对象池
对象池（Object Pool）是一种对象管理策略，其核心思想是：在真正需要使用对象之前，预先创建并维护一定数量的对象实例作为备用。当有新的对象需求时，直接从对象池中获取，而不是每次都创建新实例。使用完毕后，将对象归还到池中供后续复用。
对象池的核心优势
| 维度 | 传统对象创建 | 对象池模式 |
|---|---|---|
| 创建速度 | 每次需要构造和初始化，开销大 | 预先创建，直接取用，速度快 |
| 内存开销 | 频繁分配释放导致内存碎片 | 对象复用，减少内存分配 |
| GC压力 | 大量对象创建导致GC频繁 | 对象复用，减少GC压力 |
| 资源管理 | 需要手动管理生命周期 | 统一管理，自动回收 |
| 并发性能 | 创建过程可能阻塞 | 预创建，避免阻塞 |
适用场景分析
对象池并非适用于所有场景，需要根据对象特性进行判断：
适合对象池的对象特征：
- 创建成本高（如需要网络连接、IO操作等）
- 使用频率高
- 可以复用（无状态或可重置状态）
- 生命周期可控
不适合对象池的对象特征：
- 创建成本低（如简单POJO）
- 有状态且难以重置
- 使用频率低
- 生命周期不确定
对象池的工作原理
基本结构
获取与归还流程
核心组件
对象池通常包含以下核心组件：
- 对象工厂（Object Factory）：负责创建新对象实例
- 空闲对象队列（Idle Queue）：存储可用的对象
- 活跃对象集合（Active Set）：跟踪正在使用的对象
- 配置管理（Configuration）：管理池的大小、超时等参数
- 验证器（Validator）：验证对象是否可用
- 清理器（Cleaner）：清理对象状态
对象池的实现
Java 实现
基础对象池实现
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
/**
* 通用对象池接口
*/
public interface ObjectPool<T> {
/**
* 从池中获取对象
*/
T borrowObject() throws Exception;
/**
* 归还对象到池中
*/
void returnObject(T obj);
/**
* 获取池中空闲对象数量
*/
int getNumIdle();
/**
* 获取池中活跃对象数量
*/
int getNumActive();
/**
* 清空对象池
*/
void clear();
}
/**
* 基础对象池实现
*/
public class SimpleObjectPool<T> implements ObjectPool<T> {
private final ConcurrentLinkedQueue<T> idleObjects;
private final AtomicInteger activeCount;
private final Supplier<T> factory;
private final int maxTotal;
private final int minIdle;
private final long maxWaitMillis;
public SimpleObjectPool(Supplier<T> factory, int minIdle, int maxTotal, long maxWaitMillis) {
this.factory = factory;
this.minIdle = minIdle;
this.maxTotal = maxTotal;
this.maxWaitMillis = maxWaitMillis;
this.idleObjects = new ConcurrentLinkedQueue<>();
this.activeCount = new AtomicInteger(0);
// 初始化最小空闲对象
for (int i = 0; i < minIdle; i++) {
idleObjects.offer(factory.get());
}
}
@Override
public T borrowObject() throws Exception {
T obj = idleObjects.poll();
if (obj == null) {
if (activeCount.get() < maxTotal) {
// 创建新对象
obj = factory.get();
} else {
// 等待其他对象归还
long startTime = System.currentTimeMillis();
while ((obj = idleObjects.poll()) == null) {
if (maxWaitMillis > 0 &&
System.currentTimeMillis() - startTime > maxWaitMillis) {
throw new Exception("Timeout waiting for object from pool");
}
Thread.sleep(10);
}
}
}
activeCount.incrementAndGet();
return obj;
}
@Override
public void returnObject(T obj) {
if (obj != null) {
idleObjects.offer(obj);
activeCount.decrementAndGet();
}
}
@Override
public int getNumIdle() {
return idleObjects.size();
}
@Override
public int getNumActive() {
return activeCount.get();
}
@Override
public void clear() {
idleObjects.clear();
}
}
数据库连接池实现
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
/**
* 数据库连接池
*/
class DatabaseConnectionPool {
private final SimpleObjectPool<Connection> pool;
private final String url;
private final Properties props;
public DatabaseConnectionPool(String url, String user, String password,
int minIdle, int maxTotal) {
this.url = url;
this.props = new Properties();
this.props.setProperty("user", user);
this.props.setProperty("password", password);
this.pool = new SimpleObjectPool<>(
this::createConnection,
minIdle,
maxTotal,
5000 // 5秒超时
);
}
private Connection createConnection() throws SQLException {
return DriverManager.getConnection(url, props);
}
public Connection getConnection() throws Exception {
return pool.borrowObject();
}
public void releaseConnection(Connection conn) {
pool.returnObject(conn);
}
public void close() {
// 关闭所有连接
while (pool.getNumIdle() > 0) {
try {
Connection conn = pool.borrowObject();
conn.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void printStats() {
System.out.println("Connection Pool Stats:");
System.out.println(" Idle: " + pool.getNumIdle());
System.out.println(" Active: " + pool.getNumActive());
System.out.println(" Total: " + (pool.getNumIdle() + pool.getNumActive()));
}
}
// 使用示例
class ConnectionPoolExample {
public static void main(String[] args) throws Exception {
// 创建连接池
DatabaseConnectionPool pool = new DatabaseConnectionPool(
"jdbc:mysql://localhost:3306/mydb",
"root",
"password",
5, // 最小空闲连接
20 // 最大连接数
);
System.out.println("Initial idle: " + pool.getNumIdle());
System.out.println("Initial active: " + pool.getNumActive());
// 获取连接
Connection conn1 = pool.getConnection();
Connection conn2 = pool.getConnection();
Connection conn3 = pool.getConnection();
System.out.println("After borrow - idle: " + pool.getNumIdle());
System.out.println("After borrow - active: " + pool.getNumActive());
// 使用连接
// ... 执行SQL操作 ...
// 归还连接
pool.releaseConnection(conn1);
pool.releaseConnection(conn2);
System.out.println("After return - idle: " + pool.getNumIdle());
System.out.println("After return - active: " + pool.getNumActive());
pool.printStats();
}
}
Apache Commons Pool 集成
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
/**
* 使用 Apache Commons Pool 实现连接池
*/
class PooledConnectionFactory extends BasePooledObjectFactory<Connection> {
private final String url;
private final String user;
private final String password;
public PooledConnectionFactory(String url, String user, String password) {
this.url = url;
this.user = user;
this.password = password;
}
@Override
public Connection create() throws Exception {
return DriverManager.getConnection(url, user, password);
}
@Override
public PooledObject<Connection> wrap(Connection conn) {
return new DefaultPooledObject<>(conn);
}
@Override
public void destroyObject(PooledObject<Connection> p) throws Exception {
p.getObject().close();
super.destroyObject(p);
}
@Override
public boolean validateObject(PooledObject<Connection> p) {
try {
return p.getObject() != null && !p.getObject().isClosed();
} catch (SQLException e) {
return false;
}
}
@Override
public void passivateObject(PooledObject<Connection> p) throws Exception {
// 归还前清理
Connection conn = p.getObject();
if (!conn.getAutoCommit()) {
conn.rollback();
conn.setAutoCommit(true);
}
}
}
/**
* 高级连接池管理器
*/
class AdvancedConnectionPoolManager {
private final GenericObjectPool<Connection> pool;
public AdvancedConnectionPoolManager(String url, String user, String password) {
GenericObjectPoolConfig<Connection> config = new GenericObjectPoolConfig<>();
config.setMaxTotal(50); // 最大连接数
config.setMaxIdle(20); // 最大空闲连接
config.setMinIdle(5); // 最小空闲连接
config.setTestOnBorrow(true); // 借用时验证
config.setTestOnReturn(false); // 归还时不验证
config.setTestWhileIdle(true); // 空闲时验证
config.setTimeBetweenEvictionRunsMillis(30000); // 30秒清理一次
config.setMinEvictableIdleTimeMillis(600000); // 10分钟未使用则回收
config.setMaxWaitMillis(5000); // 最大等待5秒
this.pool = new GenericObjectPool<>(
new PooledConnectionFactory(url, user, password),
config
);
}
public Connection getConnection() throws Exception {
return pool.borrowObject();
}
public void releaseConnection(Connection conn) {
if (conn != null) {
pool.returnObject(conn);
}
}
public void close() {
pool.close();
}
public void printStats() {
System.out.println("Pool Stats:");
System.out.println(" Active: " + pool.getNumActive());
System.out.println(" Idle: " + pool.getNumIdle());
System.out.println(" Waiters: " + pool.getNumWaiters());
System.out.println(" Max Total: " + pool.getMaxTotal());
}
}
C++ 实现
基础对象池实现
#include <vector>
#include <queue>
#include <mutex>
#include <memory>
#include <stdexcept>
#include <functional>
#include <condition_variable>
/**
* 通用对象池实现
*/
template <typename T>
class ObjectPool {
public:
using FactoryFunc = std::function<std::unique_ptr<T>()>;
using ResetFunc = std::function<void(T*)>;
/**
* 构造函数
* @param factory 对象工厂函数
* @param reset 对象重置函数
* @param initialSize 初始对象数量
* @param maxSize 最大对象数量
*/
ObjectPool(FactoryFunc factory, ResetFunc reset,
size_t initialSize, size_t maxSize)
: m_factory(factory)
, m_reset(reset)
, m_maxSize(maxSize) {
// 预创建初始对象
for (size_t i = 0; i < initialSize; ++i) {
m_idleObjects.push(factory().release());
}
}
/**
* 析构函数
*/
~ObjectPool() {
std::lock_guard<std::mutex> lock(m_mutex);
// 清理所有空闲对象
while (!m_idleObjects.empty()) {
delete m_idleObjects.front();
m_idleObjects.pop();
}
// 清理所有活跃对象
for (T* obj : m_activeObjects) {
delete obj;
}
}
/**
* 获取对象
*/
T* acquire() {
std::unique_lock<std::mutex> lock(m_mutex);
// 等待直到有可用对象
m_cv.wait(lock, [this]() {
return !m_idleObjects.empty() ||
m_activeObjects.size() < m_maxSize;
});
T* obj = nullptr;
if (!m_idleObjects.empty()) {
// 从空闲队列获取
obj = m_idleObjects.front();
m_idleObjects.pop();
} else {
// 创建新对象
obj = m_factory().release();
}
m_activeObjects.insert(obj);
return obj;
}
/**
* 带超时的获取对象
*/
T* acquireWithTimeout(int timeoutMs) {
std::unique_lock<std::mutex> lock(m_mutex);
if (!m_cv.wait_for(lock, std::chrono::milliseconds(timeoutMs),
[this]() {
return !m_idleObjects.empty() ||
m_activeObjects.size() < m_maxSize;
})) {
return nullptr; // 超时
}
T* obj = nullptr;
if (!m_idleObjects.empty()) {
obj = m_idleObjects.front();
m_idleObjects.pop();
} else {
obj = m_factory().release();
}
m_activeObjects.insert(obj);
return obj;
}
/**
* 归还对象
*/
void release(T* obj) {
if (obj == nullptr) {
return;
}
std::lock_guard<std::mutex> lock(m_mutex);
// 从活跃集合移除
m_activeObjects.erase(obj);
// 重置对象状态
if (m_reset) {
m_reset(obj);
}
// 加入空闲队列
m_idleObjects.push(obj);
// 通知等待的线程
m_cv.notify_one();
}
/**
* 获取空闲对象数量
*/
size_t getIdleCount() const {
std::lock_guard<std::mutex> lock(m_mutex);
return m_idleObjects.size();
}
/**
* 获取活跃对象数量
*/
size_t getActiveCount() const {
std::lock_guard<std::mutex> lock(m_mutex);
return m_activeObjects.size();
}
private:
FactoryFunc m_factory;
ResetFunc m_reset;
size_t m_maxSize;
mutable std::mutex m_mutex;
std::condition_variable m_cv;
std::queue<T*> m_idleObjects;
std::unordered_set<T*> m_activeObjects;
};
// 使用示例
class DatabaseConnection {
public:
DatabaseConnection(const std::string& id) : m_id(id), m_closed(false) {
std::cout << "Created connection: " << m_id << std::endl;
}
~DatabaseConnection() {
close();
}
void execute(const std::string& sql) {
if (m_closed) {
throw std::runtime_error("Connection is closed");
}
std::cout << "Executing: " << sql << " on " << m_id << std::endl;
}
void close() {
if (!m_closed) {
m_closed = true;
std::cout << "Connection " << m_id << " closed" << std::endl;
}
}
bool isClosed() const {
return m_closed;
}
void reset() {
// 重置连接状态
m_closed = false;
}
private:
std::string m_id;
bool m_closed;
};
class ConnectionPoolExample {
public:
static void run() {
// 创建连接池
ObjectPool<DatabaseConnection> pool(
[]() {
static int counter = 0;
return std::make_unique<DatabaseConnection>("conn-" + std::to_string(++counter));
},
[](DatabaseConnection* conn) { conn->reset(); },
5, // 初始连接数
20 // 最大连接数
);
std::cout << "Initial idle: " << pool.getIdleCount() << std::endl;
std::cout << "Initial active: " << pool.getActiveCount() << std::endl;
// 获取连接
DatabaseConnection* conn1 = pool.acquire();
DatabaseConnection* conn2 = pool.acquire();
DatabaseConnection* conn3 = pool.acquire();
std::cout << "After acquire - idle: " << pool.getIdleCount() << std::endl;
std::cout << "After acquire - active: " << pool.getActiveCount() << std::endl;
// 使用连接
conn1->execute("SELECT * FROM users");
conn2->execute("INSERT INTO orders VALUES (1, 2, 3)");
conn3->execute("UPDATE products SET price = 100");
// 归还连接
pool.release(conn1);
pool.release(conn2);
std::cout << "After release - idle: " << pool.getIdleCount() << std::endl;
std::cout << "After release - active: " << pool.getActiveCount() << std::endl;
}
};
Python 实现
import threading
import queue
from typing import TypeVar, Generic, Callable, Optional
from contextlib import contextmanager
T = TypeVar('T')
class ObjectPool(Generic[T]):
"""
通用对象池实现
"""
def __init__(self,
factory: Callable[[], T],
reset: Optional[Callable[[T], None]] = None,
initial_size: int = 5,
max_size: int = 20):
"""
初始化对象池
Args:
factory: 对象工厂函数
reset: 对象重置函数
initial_size: 初始对象数量
max_size: 最大对象数量
"""
self.factory = factory
self.reset = reset
self.max_size = max_size
self._idle_objects = queue.Queue()
self._lock = threading.Lock()
self._active_count = 0
# 预创建初始对象
for _ in range(initial_size):
self._idle_objects.put(factory())
def acquire(self, timeout: Optional[float] = None) -> T:
"""
获取对象
Args:
timeout: 超时时间（秒），None表示无限等待
Returns:
对象实例
Raises:
queue.Empty: 超时未获取到对象
"""
with self._lock:
if self._active_count < self.max_size and self._idle_objects.empty():
# 创建新对象
obj = self.factory()
self._active_count += 1
return obj
# 从空闲队列获取
obj = self._idle_objects.get(timeout=timeout)
self._active_count += 1
return obj
def release(self, obj: T) -> None:
"""
归还对象
Args:
obj: 要归还的对象
"""
if obj is None:
return
# 重置对象状态
if self.reset:
self.reset(obj)
# 加入空闲队列
self._idle_objects.put(obj)
self._active_count -= 1
def get_idle_count(self) -> int:
"""获取空闲对象数量"""
return self._idle_objects.qsize()
def get_active_count(self) -> int:
"""获取活跃对象数量"""
return self._active_count
def clear(self) -> None:
"""清空对象池"""
while not self._idle_objects.empty():
self._idle_objects.get()
@contextmanager
def context(self, timeout: Optional[float] = None):
"""
上下文管理器，自动归还对象
Usage:
with pool.context() as obj:
# 使用对象
pass
# 自动归还
"""
obj = self.acquire(timeout)
try:
yield obj
finally:
self.release(obj)
# 数据库连接池示例
class DatabaseConnection:
def __init__(self, connection_id: str):
self.id = connection_id
self.closed = False
print(f"Created connection: {self.id}")
def execute(self, sql: str) -> None:
if self.closed:
raise RuntimeError("Connection is closed")
print(f"Executing: {sql} on {self.id}")
def close(self) -> None:
if not self.closed:
self.closed = True
print(f"Connection {self.id} closed")
def reset(self) -> None:
"""重置连接状态"""
self.closed = False
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
class DatabaseConnectionPool:
def __init__(self, connection_string: str,
initial_size: int = 5,
max_size: int = 20):
self.connection_string = connection_string
self._counter = 0
self.pool = ObjectPool(
factory=self._create_connection,
reset=lambda conn: conn.reset(),
initial_size=initial_size,
max_size=max_size
)
def _create_connection(self) -> DatabaseConnection:
"""创建新连接"""
self._counter += 1
return DatabaseConnection(f"conn-{self._counter}")
def get_connection(self, timeout: Optional[float] = None) -> DatabaseConnection:
"""获取连接"""
return self.pool.acquire(timeout)
def release_connection(self, conn: DatabaseConnection) -> None:
"""归还连接"""
self.pool.release(conn)
@contextmanager
def connection(self, timeout: Optional[float] = None):
"""连接上下文管理器"""
conn = self.get_connection(timeout)
try:
yield conn
finally:
self.release_connection(conn)
def print_stats(self) -> None:
"""打印池统计信息"""
print("Connection Pool Stats:")
print(f" Idle: {self.pool.get_idle_count()}")
print(f" Active: {self.pool.get_active_count()}")
print(f" Total: {self.pool.get_idle_count() + self.pool.get_active_count()}")
# 使用示例
def example_usage():
# 创建连接池
pool = DatabaseConnectionPool(
connection_string="mysql://localhost:3306/mydb",
initial_size=5,
max_size=20
)
print("Initial stats:")
pool.print_stats()
# 使用上下文管理器
with pool.connection() as conn:
conn.execute("SELECT * FROM users")
conn.execute("INSERT INTO orders VALUES (1, 2, 3)")
print("\nAfter using connection:")
pool.print_stats()
# 手动获取和归还
conn1 = pool.get_connection()
conn2 = pool.get_connection()
conn3 = pool.get_connection()
print("\nAfter acquiring 3 connections:")
pool.print_stats()
conn1.execute("UPDATE products SET price = 100")
conn2.execute("DELETE FROM logs WHERE date < '2024-01-01'")
conn3.execute("SELECT COUNT(*) FROM users")
pool.release_connection(conn1)
pool.release_connection(conn2)
print("\nAfter releasing 2 connections:")
pool.print_stats()
if __name__ == "__main__":
example_usage()
对象池的应用场景
1. 数据库连接池
数据库连接池是对象池最经典的应用场景之一。数据库连接的创建成本高昂，需要建立TCP连接、进行身份验证等操作。
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 数据库连接池配置
*/
@Configuration
public class DataSourceConfig {
@Bean
@ConfigurationProperties(prefix = "spring.datasource.hikari")
public DataSource dataSource() {
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("root");
config.setPassword("password");
// 连接池配置
config.setMaximumPoolSize(50); // 最大连接数
config.setMinimumIdle(10); // 最小空闲连接
config.setConnectionTimeout(30000); // 连接超时30秒
config.setIdleTimeout(600000); // 空闲超时10分钟
config.setMaxLifetime(1800000); // 最大生命周期30分钟
config.setLeakDetectionThreshold(60000); // 泄漏检测阈值60秒
// 性能优化
config.setAutoCommit(true);
config.setReadOnly(false);
config.setConnectionTestQuery("SELECT 1");
return new HikariDataSource(config);
}
}
/**
* 数据库访问示例
*/
@Repository
public class UserRepository {
@Autowired
private DataSource dataSource;
public User findById(Long id) throws SQLException {
String sql = "SELECT id, username, email, created_at FROM users WHERE id = ?";
try (Connection conn = dataSource.getConnection();
PreparedStatement stmt = conn.prepareStatement(sql)) {
stmt.setLong(1, id);
try (ResultSet rs = stmt.executeQuery()) {
if (rs.next()) {
return User.builder()
.id(rs.getLong("id"))
.username(rs.getString("username"))
.email(rs.getString("email"))
.createdAt(rs.getTimestamp("created_at").toLocalDateTime())
.build();
}
return null;
}
}
}
public void save(User user) throws SQLException {
String sql = "INSERT INTO users (username, email, created_at) VALUES (?, ?, NOW())";
try (Connection conn = dataSource.getConnection();
PreparedStatement stmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
stmt.setString(1, user.getUsername());
stmt.setString(2, user.getEmail());
int affectedRows = stmt.executeUpdate();
if (affectedRows == 0) {
throw new SQLException("Creating user failed, no rows affected.");
}
try (ResultSet generatedKeys = stmt.getGeneratedKeys()) {
if (generatedKeys.next()) {
user.setId(generatedKeys.getLong(1));
}
}
}
}
}
2. 线程池
线程池是另一个重要的对象池应用，用于管理和复用线程资源。
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 线程池配置
*/
@Configuration
public class ThreadPoolConfig {
@Bean("taskExecutor")
public ThreadPoolTaskExecutor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
// 核心线程数
executor.setCorePoolSize(10);
// 最大线程数
executor.setMaxPoolSize(50);
// 队列容量
executor.setQueueCapacity(100);
// 线程空闲时间
executor.setKeepAliveSeconds(60);
// 线程名称前缀
executor.setThreadNamePrefix("task-executor-");
// 拒绝策略
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 等待任务完成后再关闭
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(60);
executor.initialize();
return executor;
}
@Bean("asyncExecutor")
public Executor asyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(50);
executor.setThreadNamePrefix("async-executor-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.initialize();
return executor;
}
}
/**
* 线程池使用示例
*/
@Service
public class AsyncTaskService {
@Autowired
@Qualifier("taskExecutor")
private ThreadPoolTaskExecutor taskExecutor;
public void executeTask() {
taskExecutor.execute(() -> {
// 执行异步任务
System.out.println("Task executed by: " + Thread.currentThread().getName());
});
}
public Future<String> submitTask() {
return taskExecutor.submit(() -> {
// 提交任务并获取结果
Thread.sleep(1000);
return "Task completed";
});
}
public void executeBatchTasks(List<Runnable> tasks) {
List<Future<?>> futures = new ArrayList<>();
for (Runnable task : tasks) {
futures.add(taskExecutor.submit(task));
}
// 等待所有任务完成
for (Future<?> future : futures) {
try {
future.get();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
/**
* 自定义线程工厂
*/
class NamedThreadFactory implements ThreadFactory {
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
public NamedThreadFactory(String namePrefix) {
this.namePrefix = namePrefix;
}
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, namePrefix + threadNumber.getAndIncrement());
thread.setDaemon(false);
thread.setPriority(Thread.NORM_PRIORITY);
return thread;
}
}
/**
* 自定义拒绝策略
*/
class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
// 记录日志
System.err.println("Task rejected: " + r.toString());
System.err.println("Pool stats - Active: " + executor.getActiveCount() +
", Queue: " + executor.getQueue().size());
// 尝试重新提交
try {
executor.getQueue().put(r);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
3. 网络连接池
import socket
import threading
from typing import Optional
from contextlib import contextmanager
class SocketConnection:
"""TCP连接封装"""
def __init__(self, host: str, port: int, connection_id: str):
self.host = host
self.port = port
self.id = connection_id
self._socket: Optional[socket.socket] = None
self._closed = False
self._connect()
def _connect(self) -> None:
"""建立连接"""
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._socket.connect((self.host, self.port))
print(f"Connected to {self.host}:{self.port} as {self.id}")
def send(self, data: bytes) -> None:
"""发送数据"""
if self._closed or self._socket is None:
raise RuntimeError("Connection is closed")
self._socket.sendall(data)
def recv(self, buffer_size: int = 4096) -> bytes:
"""接收数据"""
if self._closed or self._socket is None:
raise RuntimeError("Connection is closed")
return self._socket.recv(buffer_size)
def reset(self) -> None:
"""重置连接状态"""
self._closed = False
if self._socket is None:
self._connect()
def close(self) -> None:
"""关闭连接"""
if not self._closed and self._socket is not None:
self._socket.close()
self._closed = True
print(f"Connection {self.id} closed")
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
class SocketConnectionPool:
"""TCP连接池"""
def __init__(self, host: str, port: int,
initial_size: int = 5,
max_size: int = 20):
self.host = host
self.port = port
self._counter = 0
self._lock = threading.Lock()
self.pool = ObjectPool(
factory=self._create_connection,
reset=lambda conn: conn.reset(),
initial_size=initial_size,
max_size=max_size
)
def _create_connection(self) -> SocketConnection:
"""创建新连接"""
with self._lock:
self._counter += 1
return SocketConnection(self.host, self.port, f"conn-{self._counter}")
def get_connection(self, timeout: Optional[float] = None) -> SocketConnection:
"""获取连接"""
return self.pool.acquire(timeout)
def release_connection(self, conn: SocketConnection) -> None:
"""归还连接"""
self.pool.release(conn)
@contextmanager
def connection(self, timeout: Optional[float] = None):
"""连接上下文管理器"""
conn = self.get_connection(timeout)
try:
yield conn
finally:
self.release_connection(conn)
def print_stats(self) -> None:
"""打印池统计信息"""
print("Socket Connection Pool Stats:")
print(f" Idle: {self.pool.get_idle_count()}")
print(f" Active: {self.pool.get_active_count()}")
print(f" Total: {self.pool.get_idle_count() + self.pool.get_active_count()}")
# 使用示例
def example_socket_pool():
# 创建连接池
pool = SocketConnectionPool(
host="localhost",
port=8080,
initial_size=3,
max_size=10
)
# 使用上下文管理器
with pool.connection() as conn:
conn.send(b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")
response = conn.recv()
print(f"Received: {len(response)} bytes")
pool.print_stats()
4. 游戏对象池
#include <vector>
#include <memory>
#include <unordered_set>
/**
* 游戏对象基类
*/
class GameObject {
public:
virtual ~GameObject() = default;
virtual void update(float deltaTime) = 0;
virtual void render() = 0;
virtual void reset() = 0;
bool isActive() const { return m_active; }
void setActive(bool active) { m_active = active; }
protected:
bool m_active = true;
};
/**
* 子弹对象
*/
class Bullet : public GameObject {
public:
void update(float deltaTime) override {
if (!m_active) return;
m_x += m_vx * deltaTime;
m_y += m_vy * deltaTime;
m_lifetime -= deltaTime;
if (m_lifetime <= 0) {
setActive(false);
}
}
void render() override {
if (!m_active) return;
// 渲染子弹
printf("Rendering bullet at (%.2f, %.2f)\n", m_x, m_y);
}
void reset() override {
m_x = 0.0f;
m_y = 0.0f;
m_vx = 0.0f;
m_vy = 0.0f;
m_lifetime = 5.0f;
setActive(true);
}
void fire(float startX, float startY, float dirX, float dirY, float speed) {
m_x = startX;
m_y = startY;
m_vx = dirX * speed;
m_vy = dirY * speed;
m_lifetime = 5.0f;
setActive(true);
}
private:
float m_x = 0.0f;
float m_y = 0.0f;
float m_vx = 0.0f;
float m_vy = 0.0f;
float m_lifetime = 5.0f;
};
/**
* 粒子对象
*/
class Particle : public GameObject {
public:
void update(float deltaTime) override {
if (!m_active) return;
m_x += m_vx * deltaTime;
m_y += m_vy * deltaTime;
m_alpha -= m_fadeRate * deltaTime;
m_scale -= m_shrinkRate * deltaTime;
if (m_alpha <= 0.0f || m_scale <= 0.0f) {
setActive(false);
}
}
void render() override {
if (!m_active) return;
// 渲染粒子
printf("Rendering particle at (%.2f, %.2f), alpha=%.2f, scale=%.2f\n",
m_x, m_y, m_alpha, m_scale);
}
void reset() override {
m_x = 0.0f;
m_y = 0.0f;
m_vx = 0.0f;
m_vy = 0.0f;
m_alpha = 1.0f;
m_scale = 1.0f;
setActive(true);
}
void spawn(float x, float y, float vx, float vy,
float alpha = 1.0f, float scale = 1.0f) {
m_x = x;
m_y = y;
m_vx = vx;
m_vy = vy;
m_alpha = alpha;
m_scale = scale;
setActive(true);
}
private:
float m_x = 0.0f;
float m_y = 0.0f;
float m_vx = 0.0f;
float m_vy = 0.0f;
float m_alpha = 1.0f;
float m_scale = 1.0f;
float m_fadeRate = 0.5f;
float m_shrinkRate = 0.3f;
};
/**
* 游戏对象池模板
*/
template <typename T, size_t PoolSize>
class GameObjectPool {
public:
GameObjectPool() {
// 预创建所有对象
for (size_t i = 0; i < PoolSize; ++i) {
auto obj = std::make_unique<T>();
obj->setActive(false);
m_objects.push_back(std::move(obj));
}
}
/**
* 从池中获取对象
*/
T* acquire() {
for (auto& obj : m_objects) {
if (!obj->isActive()) {
obj->reset();
return obj.get();
}
}
return nullptr; // 池已满
}
/**
* 更新所有活跃对象
*/
void update(float deltaTime) {
for (auto& obj : m_objects) {
if (obj->isActive()) {
obj->update(deltaTime);
}
}
}
/**
* 渲染所有活跃对象
*/
void render() {
for (auto& obj : m_objects) {
if (obj->isActive()) {
obj->render();
}
}
}
/**
* 获取活跃对象数量
*/
size_t getActiveCount() const {
size_t count = 0;
for (const auto& obj : m_objects) {
if (obj->isActive()) {
++count;
}
}
return count;
}
/**
* 清空池中所有对象
*/
void clear() {
for (auto& obj : m_objects) {
obj->setActive(false);
obj->reset();
}
}
private:
std::vector<std::unique_ptr<T>> m_objects;
};
// 使用示例
class Game {
public:
Game()
: m_bulletPool()
, m_particlePool() {
}
void update(float deltaTime) {
// 更新所有子弹
m_bulletPool.update(deltaTime);
// 更新所有粒子
m_particlePool.update(deltaTime);
// 发射新子弹
if (shouldFire()) {
fireBullet();
}
// 生成新粒子
if (shouldSpawnParticle()) {
spawnParticle();
}
}
void render() {
m_bulletPool.render();
m_particlePool.render();
}
void printStats() {
printf("Game Stats:\n");
printf(" Active bullets: %zu/%zu\n", m_bulletPool.getActiveCount(), 1000);
printf(" Active particles: %zu/%zu\n", m_particlePool.getActiveCount(), 5000);
}
private:
GameObjectPool<Bullet, 1000> m_bulletPool;
GameObjectPool<Particle, 5000> m_particlePool;
bool shouldFire() {
// 判断是否应该发射
return true;
}
void fireBullet() {
Bullet* bullet = m_bulletPool.acquire();
if (bullet) {
bullet->fire(100.0f, 100.0f, 1.0f, 0.0f, 500.0f);
}
}
bool shouldSpawnParticle() {
// 判断是否应该生成粒子
return true;
}
void spawnParticle() {
Particle* particle = m_particlePool.acquire();
if (particle) {
float angle = (float)(rand() % 360) * 3.14159f / 180.0f;
float speed = 100.0f + (float)(rand() % 100);
particle->spawn(
100.0f, 100.0f,
cos(angle) * speed,
sin(angle) * speed,
1.0f, 1.0f
);
}
}
};
对象池的最佳实践
1. 合理设置池大小
池大小的设置需要综合考虑系统资源、并发量、对象创建成本等因素。
/**
* 池大小计算器
*/
class PoolSizeCalculator {
/**
* 计算推荐的数据库连接池大小
* 公式：连接数 = ((核心数 * 2) + 有效磁盘数)
*/
public static int calculateDbPoolSize(int cpuCores, int diskCount) {
return (cpuCores * 2) + diskCount;
}
/**
* 计算线程池大小
* CPU密集型：核心数 + 1
* IO密集型：核心数 * 2
*/
public static int calculateThreadPoolSize(int cpuCores, boolean ioIntensive) {
return ioIntensive ? cpuCores * 2 : cpuCores + 1;
}
/**
* 根据内存限制计算对象池大小
*/
public static int calculatePoolSizeByMemory(long maxMemory, long objectSize,
double usageRatio) {
long availableMemory = (long)(maxMemory * usageRatio);
return (int)(availableMemory / objectSize);
}
/**
* 根据并发量计算池大小
* 使用利特尔法则：L = λW
* L = 系统中平均请求数
* λ = 请求到达速率
* W = 平均请求处理时间
*/
public static int calculatePoolSizeByConcurrency(int requestsPerSecond,
int avgRequestTimeMs) {
double lambda = requestsPerSecond;
double w = avgRequestTimeMs / 1000.0; // 转换为秒
double l = lambda * w;
return (int) Math.ceil(l * 1.5); // 增加50%缓冲
}
}
// 使用示例
class PoolConfiguration {
public static void main(String[] args) {
int cpuCores = Runtime.getRuntime().availableProcessors();
int diskCount = 1;
// 计算数据库连接池大小
int dbPoolSize = PoolSizeCalculator.calculateDbPoolSize(cpuCores, diskCount);
System.out.println("Recommended DB pool size: " + dbPoolSize);
// 计算线程池大小
int threadPoolSize = PoolSizeCalculator.calculateThreadPoolSize(cpuCores, true);
System.out.println("Recommended thread pool size: " + threadPoolSize);
// 计算对象池大小
long maxMemory = 1024 * 1024 * 1024; // 1GB
long objectSize = 1024; // 1KB per object
int poolSize = PoolSizeCalculator.calculatePoolSizeByMemory(maxMemory, objectSize, 0.5);
System.out.println("Object pool size: " + poolSize);
// 根据并发量计算
int requestsPerSecond = 1000;
int avgRequestTimeMs = 50;
int concurrencyPoolSize = PoolSizeCalculator.calculatePoolSizeByConcurrency(
requestsPerSecond, avgRequestTimeMs);
System.out.println("Concurrency-based pool size: " + concurrencyPoolSize);
}
}
2. 对象验证与清理
对象归还时需要进行验证和清理，确保下次使用时状态正确。
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
/**
* 可验证的对象池工厂
*/
class ValidatableConnectionFactory extends BasePooledObjectFactory<Connection> {
private final String url;
private final String user;
private final String password;
public ValidatableConnectionFactory(String url, String user, String password) {
this.url = url;
this.user = user;
this.password = password;
}
@Override
public Connection create() throws Exception {
return DriverManager.getConnection(url, user, password);
}
@Override
public PooledObject<Connection> wrap(Connection conn) {
return new DefaultPooledObject<>(conn);
}
/**
* 验证对象是否可用
*/
@Override
public boolean validateObject(PooledObject<Connection> p) {
Connection conn = p.getObject();
try {
// 检查连接是否仍然有效
if (conn == null || conn.isClosed()) {
return false;
}
// 执行简单查询验证
try (Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT 1")) {
return rs.next() && rs.getInt(1) == 1;
}
} catch (SQLException e) {
return false;
}
}
/**
* 激活对象 - 从池中取出时调用
*/
@Override
public void activateObject(PooledObject<Connection> p) throws Exception {
Connection conn = p.getObject();
// 重置连接状态
if (conn.getAutoCommit()) {
conn.setAutoCommit(true);
}
}
/**
* 钝化对象 - 归还到池中时调用
*/
@Override
public void passivateObject(PooledObject<Connection> p) throws Exception {
Connection conn = p.getObject();
// 清理连接状态
if (!conn.getAutoCommit()) {
conn.rollback();
conn.setAutoCommit(true);
}
// 清理未关闭的语句
try {
if (!conn.isClosed()) {
// 清理可能未关闭的资源
conn.clearWarnings();
}
} catch (SQLException e) {
// 忽略清理错误
}
}
/**
* 销毁对象
*/
@Override
public void destroyObject(PooledObject<Connection> p) throws Exception {
Connection conn = p.getObject();
if (conn != null && !conn.isClosed()) {
conn.close();
}
}
}
/**
* 带状态清理的对象池
*/
class StateAwareObjectPool<T> implements ObjectPool<T> {
private final SimpleObjectPool<T> pool;
private final Consumer<T> stateCleaner;
public StateAwareObjectPool(Supplier<T> factory, Consumer<T> stateCleaner,
int minIdle, int maxTotal) {
this.stateCleaner = stateCleaner;
this.pool = new SimpleObjectPool<>(factory, minIdle, maxTotal);
}
@Override
public T borrowObject() throws Exception {
T obj = pool.borrowObject();
// 借用时清理状态
if (stateCleaner != null) {
stateCleaner.accept(obj);
}
return obj;
}
@Override
public void returnObject(T obj) {
// 归还前清理状态
if (stateCleaner != null) {
stateCleaner.accept(obj);
}
pool.returnObject(obj);
}
@Override
public int getNumIdle() {
return pool.getNumIdle();
}
@Override
public int getNumActive() {
return pool.getNumActive();
}
@Override
public void clear() {
pool.clear();
}
}
// 使用示例 - StringBuilder池
class StringBuilderPool {
private final StateAwareObjectPool<StringBuilder> pool;
public StringBuilderPool(int poolSize) {
this.pool = new StateAwareObjectPool<>(
StringBuilder::new,
sb -> sb.setLength(0), // 清理状态
poolSize / 2,
poolSize
);
}
public StringBuilder borrow() throws Exception {
return pool.borrowObject();
}
public void returnObject(StringBuilder sb) {
pool.returnObject(sb);
}
}
3. 监控与调优
对象池的监控对于性能优化和问题诊断至关重要。
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
/**
* 池监控器
*/
class PoolMonitor<T> {
private final ObjectPool<T> pool;
private final ScheduledExecutorService scheduler;
private final String poolName;
private final AtomicLong totalBorrows = new AtomicLong(0);
private final AtomicLong totalReturns = new AtomicLong(0);
private final AtomicLong failedBorrows = new AtomicLong(0);
private final AtomicLong borrowTimeSum = new AtomicLong(0);
public PoolMonitor(ObjectPool<T> pool, String poolName) {
this.pool = pool;
this.poolName = poolName;
this.scheduler = Executors.newSingleThreadScheduledExecutor();
startMonitoring();
}
private void startMonitoring() {
scheduler.scheduleAtFixedRate(this::reportStats, 1, 1, TimeUnit.MINUTES);
}
/**
* 记录借用
*/
public void recordBorrow(long durationNanos, boolean success) {
totalBorrows.incrementAndGet();
if (success) {
borrowTimeSum.addAndGet(durationNanos);
} else {
failedBorrows.incrementAndGet();
}
}
/**
* 记录归还
*/
public void recordReturn() {
totalReturns.incrementAndGet();
}
private void reportStats() {
System.out.println("=== Pool Stats: " + poolName + " ===");
System.out.println(" Idle: " + pool.getNumIdle());
System.out.println(" Active: " + pool.getNumActive());
System.out.println(" Total: " + (pool.getNumIdle() + pool.getNumActive()));
System.out.println(" Total Borrows: " + totalBorrows.get());
System.out.println(" Total Returns: " + totalReturns.get());
System.out.println(" Failed Borrows: " + failedBorrows.get());
// 计算平均借用时间
long borrows = totalBorrows.get();
if (borrows > 0) {
long avgTime = borrowTimeSum.get() / borrows;
System.out.println(" Avg Borrow Time: " + avgTime + " ns");
}
// 计算利用率
int total = pool.getNumIdle() + pool.getNumActive();
if (total > 0) {
double utilization = (double) pool.getNumActive() / total * 100;
System.out.println(" Utilization: " + String.format("%.2f%%", utilization));
// 警告检查
if (utilization > 90) {
System.out.println(" WARNING: High utilization! Consider increasing pool size.");
}
}
// 计算失败率
if (borrows > 0) {
double failureRate = (double) failedBorrows.get() / borrows * 100;
System.out.println(" Failure Rate: " + String.format("%.2f%%", failureRate));
if (failureRate > 5) {
System.out.println(" WARNING: High failure rate! Check pool configuration.");
}
}
System.out.println();
}
public void shutdown() {
scheduler.shutdown();
}
}
/**
* 带监控的对象池包装器
*/
class MonitoredObjectPool<T> implements ObjectPool<T> {
private final ObjectPool<T> delegate;
private final PoolMonitor<T> monitor;
public MonitoredObjectPool(ObjectPool<T> delegate, String poolName) {
this.delegate = delegate;
this.monitor = new PoolMonitor<>(delegate, poolName);
}
@Override
public T borrowObject() throws Exception {
long startTime = System.nanoTime();
try {
T obj = delegate.borrowObject();
long duration = System.nanoTime() - startTime;
monitor.recordBorrow(duration, true);
return obj;
} catch (Exception e) {
long duration = System.nanoTime() - startTime;
monitor.recordBorrow(duration, false);
throw e;
}
}
@Override
public void returnObject(T obj) {
delegate.returnObject(obj);
monitor.recordReturn();
}
@Override
public int getNumIdle() {
return delegate.getNumIdle();
}
@Override
public int getNumActive() {
return delegate.getNumActive();
}
@Override
public void clear() {
delegate.clear();
}
public void shutdown() {
monitor.shutdown();
}
}
对象池的性能优化
1. 分级对象池
根据对象大小和使用频率，使用多级对象池。
import java.util.HashMap;
import java.util.Map;
/**
* 分级对象池
* 根据对象大小选择合适的池
*/
class TieredObjectPool<T> {
private final Map<Integer, ObjectPool<T>> pools;
private final Supplier<T> factory;
private final Consumer<T> cleaner;
private final int[] sizeThresholds;
public TieredObjectPool(Supplier<T> factory, Consumer<T> cleaner,
int[] sizeThresholds, int poolSize) {
this.factory = factory;
this.cleaner = cleaner;
this.sizeThresholds = sizeThresholds;
this.pools = new HashMap<>();
// 为每个大小级别创建池
for (int size : sizeThresholds) {
pools.put(size, createPool(poolSize));
}
}
private ObjectPool<T> createPool(int poolSize) {
return new SimpleObjectPool<>(factory, cleaner, poolSize / 2, poolSize);
}
/**
* 根据对象大小获取合适的池
*/
private ObjectPool<T> getPool(int size) {
for (int threshold : sizeThresholds) {
if (size <= threshold) {
return pools.get(threshold);
}
}
// 返回最大的池
return pools.get(sizeThresholds[sizeThresholds.length - 1]);
}
/**
* 获取对象
*/
public T acquire(int size) throws Exception {
return getPool(size).borrowObject();
}
/**
* 归还对象
*/
public void release(T obj, int size) {
getPool(size).returnObject(obj);
}
/**
* 打印统计信息
*/
public void printStats() {
System.out.println("Tiered Pool Stats:");
for (Map.Entry<Integer, ObjectPool<T>> entry : pools.entrySet()) {
int size = entry.getKey();
ObjectPool<T> pool = entry.getValue();
System.out.printf(" Size %d - Idle: %d, Active: %d%n",
size, pool.getNumIdle(), pool.getNumActive());
}
}
}
2. 线程本地对象池
避免线程竞争，每个线程维护独立的对象池。
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 线程本地对象池
*/
class ThreadLocalObjectPool<T> implements ObjectPool<T> {
private final ThreadLocal<LocalPool> threadLocalPool;
private final Supplier<T> factory;
private final int maxPerThread;
private final AtomicInteger totalActiveCount;
public ThreadLocalObjectPool(Supplier<T> factory, int maxPerThread) {
this.factory = factory;
this.maxPerThread = maxPerThread;
this.threadLocalPool = ThreadLocal.withInitial(() -> new LocalPool());
this.totalActiveCount = new AtomicInteger(0);
}
@Override
public T borrowObject() throws Exception {
return threadLocalPool.get().borrowObject();
}
@Override
public void returnObject(T obj) {
threadLocalPool.get().returnObject(obj);
}
@Override
public int getNumIdle() {
// 线程本地池无法准确统计总数
return -1;
}
@Override
public int getNumActive() {
return totalActiveCount.get();
}
@Override
public void clear() {
// 清空当前线程的池
threadLocalPool.get().clear();
}
/**
* 本地池实现
*/
private class LocalPool {
private final java.util.Queue<T> idleObjects;
private int activeCount;
public LocalPool() {
this.idleObjects = new java.util.LinkedList<>();
this.activeCount = 0;
}
public T borrowObject() throws Exception {
T obj = idleObjects.poll();
if (obj == null) {
if (activeCount < maxPerThread) {
obj = factory.get();
} else {
throw new Exception("Thread local pool exhausted");
}
}
activeCount++;
totalActiveCount.incrementAndGet();
return obj;
}
public void returnObject(T obj) {
if (obj != null) {
idleObjects.offer(obj);
activeCount--;
totalActiveCount.decrementAndGet();
}
}
public void clear() {
idleObjects.clear();
activeCount = 0;
}
}
}
// 使用示例
class ThreadLocalPoolExample {
public static void main(String[] args) throws Exception {
ThreadLocalObjectPool<StringBuilder> pool =
new ThreadLocalObjectPool<>(StringBuilder::new, 100);
Runnable task = () -> {
try {
for (int i = 0; i < 1000; i++) {
StringBuilder sb = pool.borrowObject();
sb.append("Thread: ").append(Thread.currentThread().getId());
sb.append(", Iteration: ").append(i);
// 使用 sb
pool.returnObject(sb);
}
} catch (Exception e) {
e.printStackTrace();
}
};
// 创建多个线程
Thread[] threads = new Thread[10];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(task);
threads[i].start();
}
for (Thread t : threads) {
t.join();
}
System.out.println("Total active: " + pool.getNumActive());
}
}
3. 自适应对象池
根据使用模式动态调整池大小。
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
/**
* 自适应对象池
* 根据使用模式动态调整池大小
*/
class AdaptiveObjectPool<T> implements ObjectPool<T> {
private final ConcurrentLinkedQueue<T> idleObjects;
private final AtomicInteger activeCount;
private final AtomicLong peakUsage;
private final Supplier<T> factory;
private final int initialSize;
private final int maxSize;
private final int expandThreshold;
private final int shrinkThreshold;
private volatile long lastAdjustmentTime;
private final long adjustmentInterval;
public AdaptiveObjectPool(Supplier<T> factory, int initialSize, int maxSize) {
this.factory = factory;
this.initialSize = initialSize;
this.maxSize = maxSize;
this.expandThreshold = (int)(maxSize * 0.8); // 80%使用率时扩容
this.shrinkThreshold = (int)(initialSize * 0.5); // 50%使用率时收缩
this.adjustmentInterval = 60000; // 60秒调整间隔
this.idleObjects = new ConcurrentLinkedQueue<>();
this.activeCount = new AtomicInteger(0);
this.peakUsage = new AtomicLong(0);
this.lastAdjustmentTime = System.currentTimeMillis();
// 初始分配
for (int i = 0; i < initialSize; i++) {
idleObjects.offer(factory.get());
}
}
@Override
public T borrowObject() throws Exception {
T obj = idleObjects.poll();
if (obj == null) {
int currentTotal = activeCount.get() + idleObjects.size();
if (currentTotal < maxSize) {
// 检查是否需要扩容
if (activeCount.get() >= expandThreshold) {
expand();
}
obj = factory.get();
} else {
// 池已满，等待
while ((obj = idleObjects.poll()) == null) {
Thread.sleep(10);
}
}
}
int currentActive = activeCount.incrementAndGet();
// 更新峰值使用量
long currentPeak = peakUsage.get();
while (currentActive > currentPeak) {
if (peakUsage.compareAndSet(currentPeak, currentActive)) {
break;
}
currentPeak = peakUsage.get();
}
// 检查是否需要调整池大小
adjustPoolSizeIfNeeded();
return obj;
}
@Override
public void returnObject(T obj) {
if (obj != null) {
idleObjects.offer(obj);
activeCount.decrementAndGet();
// 检查是否需要调整池大小
adjustPoolSizeIfNeeded();
}
}
@Override
public int getNumIdle() {
return idleObjects.size();
}
@Override
public int getNumActive() {
return activeCount.get();
}
@Override
public void clear() {
idleObjects.clear();
}
/**
* 调整池大小
*/
private void adjustPoolSizeIfNeeded() {
long currentTime = System.currentTimeMillis();
if (currentTime - lastAdjustmentTime < adjustmentInterval) {
return; // 未到调整时间
}
int currentTotal = activeCount.get() + idleObjects.size();
long peak = peakUsage.get();
// 扩容
if (activeCount.get() >= expandThreshold && currentTotal < maxSize) {
expand();
}
// 收缩
else if (activeCount.get() < shrinkThreshold && currentTotal > initialSize) {
shrink();
}
}
/**
* 扩容
*/
private void expand() {
int currentTotal = activeCount.get() + idleObjects.size();
int expandSize = Math.min(initialSize, maxSize - currentTotal);
for (int i = 0; i < expandSize; i++) {
idleObjects.offer(factory.get());
}
lastAdjustmentTime = System.currentTimeMillis();
System.out.println("Pool expanded by " + expandSize + " objects");
}
/**
* 收缩
*/
private void shrink() {
int currentTotal = activeCount.get() + idleObjects.size();
int targetSize = Math.max(initialSize, (int)(peakUsage.get() * 0.7));
int removed = 0;
while (idleObjects.size() > targetSize) {
idleObjects.poll();
removed++;
}
if (removed > 0) {
peakUsage.set(activeCount.get());
lastAdjustmentTime = System.currentTimeMillis();
System.out.println("Pool shrunk by " + removed + " objects");
}
}
/**
* 获取统计信息
*/
public void printStats() {
System.out.println("Adaptive Pool Stats:");
System.out.println(" Idle: " + getNumIdle());
System.out.println(" Active: " + getNumActive());
System.out.println(" Peak Usage: " + peakUsage.get());
System.out.println(" Total: " + (getNumIdle() + getNumActive()));
}
}
常见陷阱与解决方案
1. 内存泄漏
对象未正确归还导致池耗尽。
import java.lang.ref.WeakReference;
import java.util.IdentityHashMap;
import java.util.Map;
/**
* 内存泄漏检测器
*/
class MemoryLeakDetector<T> {
private final Map<T, StackTraceElement[]> allocationTraces;
private final Map<T, Long> allocationTimes;
private final long leakThresholdMs;
public MemoryLeakDetector(long leakThresholdMs) {
this.leakThresholdMs = leakThresholdMs;
this.allocationTraces = new IdentityHashMap<>();
this.allocationTimes = new IdentityHashMap<>();
}
/**
* 记录分配
*/
public void recordAllocation(T obj) {
allocationTraces.put(obj, Thread.currentThread().getStackTrace());
allocationTimes.put(obj, System.currentTimeMillis());
}
/**
* 记录释放
*/
public void recordDeallocation(T obj) {
allocationTraces.remove(obj);
allocationTimes.remove(obj);
}
/**
* 检测泄漏
*/
public void detectLeaks() {
long currentTime = System.currentTimeMillis();
System.out.println("=== Memory Leak Detection ===");
System.out.println("Active objects: " + allocationTimes.size());
int leakCount = 0;
for (Map.Entry<T, Long> entry : allocationTimes.entrySet()) {
long allocatedTime = entry.getValue();
long elapsed = currentTime - allocatedTime;
if (elapsed > leakThresholdMs) {
leakCount++;
System.out.println("\nPotential leak detected!");
System.out.println("Object: " + entry.getKey());
System.out.println("Allocated: " + elapsed + " ms ago");
System.out.println("Allocation trace:");
StackTraceElement[] trace = allocationTraces.get(entry.getKey());
for (StackTraceElement element : trace) {
System.out.println(" at " + element);
}
}
}
if (leakCount == 0) {
System.out.println("No leaks detected.");
}
}
/**
* 获取活跃对象数量
*/
public int getActiveCount() {
return allocationTimes.size();
}
}
/**
* 防内存泄漏的对象池
*/
class LeakSafeObjectPool<T> implements ObjectPool<T> {
private final ObjectPool<T> delegate;
private final MemoryLeakDetector<T> leakDetector;
private final ThreadLocal<Map<T, Long>> borrowedObjects;
public LeakSafeObjectPool(ObjectPool<T> delegate, long leakThresholdMs) {
this.delegate = delegate;
this.leakDetector = new MemoryLeakDetector<>(leakThresholdMs);
this.borrowedObjects = ThreadLocal.withInitial(IdentityHashMap::new);
}
@Override
public T borrowObject() throws Exception {
T obj = delegate.borrowObject();
leakDetector.recordAllocation(obj);
borrowedObjects.get().put(obj, System.currentTimeMillis());
return obj;
}
@Override
public void returnObject(T obj) {
if (obj != null) {
borrowedObjects.get().remove(obj);
leakDetector.recordDeallocation(obj);
delegate.returnObject(obj);
}
}
@Override
public int getNumIdle() {
return delegate.getNumIdle();
}
@Override
public int getNumActive() {
return delegate.getNumActive();
}
@Override
public void clear() {
delegate.clear();
}
/**
* 检测泄漏
*/
public void detectLeaks() {
leakDetector.detectLeaks();
}
/**
* 确保当前线程的所有对象都被归还
*/
public void ensureAllReturned() {
Map<T, Long> borrowed = borrowedObjects.get();
if (!borrowed.isEmpty()) {
System.err.println("Warning: " + borrowed.size() + " objects not returned!");
for (Map.Entry<T, Long> entry : borrowed.entrySet()) {
System.err.println(" Object: " + entry.getKey());
System.err.println(" Borrowed: " +
(System.currentTimeMillis() - entry.getValue()) + " ms ago");
// 强制归还
returnObject(entry.getKey());
}
}
}
}
2. 线程安全问题
多线程环境下的竞争条件。
#include <mutex>
#include <condition_variable>
#include <atomic>
/**
* 线程安全的阻塞式对象池
*/
template <typename T>
class BlockingObjectPool {
public:
using FactoryFunc = std::function<std::unique_ptr<T>()>;
using ResetFunc = std::function<void(T*)>;
BlockingObjectPool(FactoryFunc factory, ResetFunc reset,
size_t initialSize, size_t maxSize)
: m_factory(factory)
, m_reset(reset)
, m_maxSize(maxSize) {
// 预创建初始对象
for (size_t i = 0; i < initialSize; ++i) {
m_idleObjects.push(factory().release());
}
}
/**
* 阻塞式获取对象
*/
T* acquire() {
std::unique_lock<std::mutex> lock(m_mutex);
// 等待直到有可用对象
m_cv.wait(lock, [this]() {
return !m_idleObjects.empty() ||
m_activeObjects.size() < m_maxSize;
});
T* obj = nullptr;
if (!m_idleObjects.empty()) {
// 从空闲队列获取
obj = m_idleObjects.front();
m_idleObjects.pop();
} else {
// 创建新对象
obj = m_factory().release();
}
m_activeObjects.insert(obj);
return obj;
}
/**
* 带超时的获取对象
*/
T* acquireWithTimeout(int timeoutMs) {
std::unique_lock<std::mutex> lock(m_mutex);
if (!m_cv.wait_for(lock, std::chrono::milliseconds(timeoutMs),
[this]() {
return !m_idleObjects.empty() ||
m_activeObjects.size() < m_maxSize;
})) {
return nullptr; // 超时
}
T* obj = nullptr;
if (!m_idleObjects.empty()) {
obj = m_idleObjects.front();
m_idleObjects.pop();
} else {
obj = m_factory().release();
}
m_activeObjects.insert(obj);
return obj;
}
/**
* 释放对象
*/
void release(T* obj) {
if (obj == nullptr) {
return;
}
std::lock_guard<std::mutex> lock(m_mutex);
// 从活跃集合移除
m_activeObjects.erase(obj);
// 重置对象状态
if (m_reset) {
m_reset(obj);
}
// 加入空闲队列
m_idleObjects.push(obj);
// 通知等待的线程
m_cv.notify_one();
}
/**
* 获取空闲对象数量
*/
size_t getIdleCount() const {
std::lock_guard<std::mutex> lock(m_mutex);
return m_idleObjects.size();
}
/**
* 获取活跃对象数量
*/
size_t getActiveCount() const {
std::lock_guard<std::mutex> lock(m_mutex);
return m_activeObjects.size();
}
private:
void expand(size_t count) {
size_t chunkSize = count;
for (size_t i = 0; i < count; ++i) {
m_idleObjects.push(m_factory().release());
}
}
FactoryFunc m_factory;
ResetFunc m_reset;
size_t m_maxSize;
mutable std::mutex m_mutex;
std::condition_variable m_cv;
std::queue<T*> m_idleObjects;
std::unordered_set<T*> m_activeObjects;
};
3. 对象状态污染
对象复用时未正确清理状态。
/**
* 带状态清理的对象池
*/
class StateAwareObjectPool<T> implements ObjectPool<T> {
private final SimpleObjectPool<T> pool;
private final Consumer<T> stateCleaner;
private final Consumer<T> stateValidator;
public StateAwareObjectPool(Supplier<T> factory,
Consumer<T> stateCleaner,
Consumer<T> stateValidator,
int minIdle, int maxTotal) {
this.stateCleaner = stateCleaner;
this.stateValidator = stateValidator;
this.pool = new SimpleObjectPool<>(factory, minIdle, maxTotal);
}
@Override
public T borrowObject() throws Exception {
T obj = pool.borrowObject();
// 借用时验证状态
if (stateValidator != null) {
stateValidator.accept(obj);
}
// 借用时清理状态
if (stateCleaner != null) {
stateCleaner.accept(obj);
}
return obj;
}
@Override
public void returnObject(T obj) {
// 归还前清理状态
if (stateCleaner != null) {
stateCleaner.accept(obj);
}
pool.returnObject(obj);
}
@Override
public int getNumIdle() {
return pool.getNumIdle();
}
@Override
public int getNumActive() {
return pool.getNumActive();
}
@Override
public void clear() {
pool.clear();
}
}
// 使用示例 - StringBuilder池
class StringBuilderPool {
private final StateAwareObjectPool<StringBuilder> pool;
public StringBuilderPool(int poolSize) {
this.pool = new StateAwareObjectPool<>(
StringBuilder::new,
sb -> sb.setLength(0), // 清理状态
sb -> {
// 验证状态
if (sb.capacity() > 10000) {
sb.setLength(0);
sb.trimToSize();
}
},
poolSize / 2,
poolSize
);
}
public StringBuilder borrow() throws Exception {
return pool.borrowObject();
}
public void returnObject(StringBuilder sb) {
pool.returnObject(sb);
}
}
对象池的监控与诊断
性能指标监控
import java.util.concurrent.atomic.AtomicLong;
/**
* 对象池性能指标收集器
*/
class PoolMetrics {
private final AtomicLong totalAllocations = new AtomicLong(0);
private final AtomicLong totalDeallocations = new AtomicLong(0);
private final AtomicLong totalAllocationTime = new AtomicLong(0);
private final AtomicLong totalDeallocationTime = new AtomicLong(0);
private final AtomicLong allocationFailures = new AtomicLong(0);
private final AtomicLong peakActiveObjects = new AtomicLong(0);
/**
* 记录分配
*/
public void recordAllocation(long durationNanos, boolean success) {
totalAllocations.incrementAndGet();
if (success) {
totalAllocationTime.addAndGet(durationNanos);
} else {
allocationFailures.incrementAndGet();
}
}
/**
* 记录释放
*/
public void recordDeallocation(long durationNanos) {
totalDeallocations.incrementAndGet();
totalDeallocationTime.addAndGet(durationNanos);
}
/**
* 更新活跃对象峰值
*/
public void updatePeakActive(int currentActive) {
int currentPeak = peakActiveObjects.get();
while (currentActive > currentPeak) {
if (peakActiveObjects.compareAndSet(currentPeak, currentActive)) {
break;
}
currentPeak = peakActiveObjects.get();
}
}
/**
* 生成性能报告
*/
public void generateReport() {
System.out.println("=== Pool Performance Metrics ===");
System.out.println("Total Allocations: " + totalAllocations.get());
System.out.println("Total Deallocations: " + totalDeallocations.get());
System.out.println("Allocation Failures: " + allocationFailures.get());
System.out.println("Peak Active Objects: " + peakActiveObjects.get());
long totalAlloc = totalAllocations.get();
if (totalAlloc > 0) {
long avgAllocTime = totalAllocationTime.get() / totalAlloc;
System.out.println("Avg Allocation Time: " + avgAllocTime + " ns");
long failRate = (allocationFailures.get() * 100) / totalAlloc;
System.out.println("Failure Rate: " + failRate + "%");
}
long totalDealloc = totalDeallocations.get();
if (totalDealloc > 0) {
long avgDeallocTime = totalDeallocationTime.get() / totalDealloc;
System.out.println("Avg Deallocation Time: " + avgDeallocTime + " ns");
}
}
/**
* 重置指标
*/
public void reset() {
totalAllocations.set(0);
totalDeallocations.set(0);
totalAllocationTime.set(0);
totalDeallocationTime.set(0);
allocationFailures.set(0);
peakActiveObjects.set(0);
}
}
/**
* 带指标收集的对象池
*/
class InstrumentedObjectPool<T> implements ObjectPool<T> {
private final ObjectPool<T> delegate;
private final PoolMetrics metrics;
public InstrumentedObjectPool(ObjectPool<T> delegate, PoolMetrics metrics) {
this.delegate = delegate;
this.metrics = metrics;
}
@Override
public T borrowObject() throws Exception {
long startTime = System.nanoTime();
try {
T obj = delegate.borrowObject();
long duration = System.nanoTime() - startTime;
metrics.recordAllocation(duration, true);
metrics.updatePeakActive(delegate.getNumActive());
return obj;
} catch (Exception e) {
long duration = System.nanoTime() - startTime;
metrics.recordAllocation(duration, false);
throw e;
}
}
@Override
public void returnObject(T obj) {
long startTime = System.nanoTime();
delegate.returnObject(obj);
long duration = System.nanoTime() - startTime;
metrics.recordDeallocation(duration);
}
@Override
public int getNumIdle() {
return delegate.getNumIdle();
}
@Override
public int getNumActive() {
return delegate.getNumActive();
}
@Override
public void clear() {
delegate.clear();
}
public PoolMetrics getMetrics() {
return metrics;
}
}
内存泄漏检测
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 内存泄漏检测器
*/
class MemoryLeakDetector<T> {
private final Map<T, StackTraceElement[]> allocationTraces;
private final Map<T, Long> allocationTimes;
private final long leakThresholdMs;
public MemoryLeakDetector(long leakThresholdMs) {
this.leakThresholdMs = leakThresholdMs;
this.allocationTraces = new IdentityHashMap<>();
this.allocationTimes = new IdentityHashMap<>();
}
/**
* 记录分配
*/
public void recordAllocation(T obj) {
allocationTraces.put(obj, Thread.currentThread().getStackTrace());
allocationTimes.put(obj, System.currentTimeMillis());
}
/**
* 记录释放
*/
public void recordDeallocation(T obj) {
allocationTraces.remove(obj);
allocationTimes.remove(obj);
}
/**
* 检测泄漏
*/
public void detectLeaks() {
long currentTime = System.currentTimeMillis();
System.out.println("=== Memory Leak Detection ===");
System.out.println("Active objects: " + allocationTimes.size());
int leakCount = 0;
for (Map.Entry<T, Long> entry : allocationTimes.entrySet()) {
long allocatedTime = entry.getValue();
long elapsed = currentTime - allocatedTime;
if (elapsed > leakThresholdMs) {
leakCount++;
System.out.println("\nPotential leak detected!");
System.out.println("Object: " + entry.getKey());
System.out.println("Allocated: " + elapsed + " ms ago");
System.out.println("Allocation trace:");
StackTraceElement[] trace = allocationTraces.get(entry.getKey());
for (StackTraceElement element : trace) {
System.out.println(" at " + element);
}
}
}
if (leakCount == 0) {
System.out.println("No leaks detected.");
}
}
/**
* 获取活跃对象数量
*/
public int getActiveCount() {
return allocationTimes.size();
}
}
总结
对象池技术是高性能系统设计中的黄金法则之一，通过预创建、统一管理的策略，有效解决了传统对象创建方式中的性能瓶颈和资源浪费问题。
核心要点
-
避免频繁创建销毁：对象池通过批量预创建，减少对象创建开销，显著提升获取速度。
-
减少GC压力：对象复用减少了垃圾回收的压力，提升了系统整体性能。
-
统一资源管理：通过池化方式统一管理对象生命周期，降低了资源泄漏的风险。
-
线程安全设计：根据场景选择合适的并发控制策略，平衡性能与安全性。
-
智能扩缩容：根据使用模式动态调整池大小，在性能和资源之间找到平衡。
适用场景
- 数据库连接池
- 线程池
- TCP/RPC连接池
- 网络缓冲区池
- 游戏对象池（子弹、粒子等）
- 任何频繁创建销毁相同类型对象的场景
最佳实践
-
合理设置池大小：根据并发量、对象创建成本、系统资源综合计算。
-
对象状态管理：确保对象复用时状态被正确清理和验证。
-
监控与诊断：建立完善的监控体系，及时发现和解决问题。
-
分级池设计：根据对象大小和使用频率，采用多级池策略。
-
避免内存泄漏：确保所有分配的对象都能正确归还。
性能对比
| 指标 | 传统创建 | 对象池 | 提升 |
|---|---|---|---|
| 获取速度 | ~1000ns | ~10ns | 100x |
| GC压力 | 高 | 低 | 显著降低 |
| 内存开销 | 大 | 小 | 节省50%+ |
| 并发性能 | 锁竞争大 | 可优化 | 10x+ |
主流对象池框架
| 框架 | 语言 | 特点 |
|---|---|---|
| Apache Commons Pool | Java | 功能完善，配置灵活 |
| HikariCP | Java | 高性能数据库连接池 |
| Netty Recycler | Java | 高性能网络对象池 |
| Boost.Pool | C++ | C++标准库组件 |
| concurrent.futures | Python | Python内置线程池 |
附录
A. 对象池配置参考
# 数据库连接池配置示例
database:
connection-pool:
# 基础配置
url: jdbc:mysql://localhost:3306/mydb
username: root
password: password
driver-class-name: com.mysql.cj.jdbc.Driver
# 池大小配置
initial-size: 10 # 初始连接数
min-idle: 5 # 最小空闲连接
max-active: 50 # 最大活跃连接
max-total: 50 # 最大连接数
# 超时配置
max-wait: 5000 # 最大等待时间（毫秒）
time-between-eviction-runs: 60000 # 清理间隔（毫秒）
min-evictable-idle-time: 300000 # 最小空闲时间（毫秒）
# 验证配置
test-on-borrow: true # 借用时验证
test-on-return: false # 归还时不验证
test-while-idle: true # 空闲时验证
validation-query: SELECT 1 # 验证查询
# 生命周期配置
max-lifetime: 1800000 # 最大生命周期（毫秒）
remove-abandoned: true # 移除废弃连接
remove-abandoned-timeout: 300000 # 废弃超时（毫秒）
# 泄漏检测
log-abandoned: true # 记录废弃连接
leak-detection-threshold: 60000 # 泄漏检测阈值（毫秒）
# 线程池配置示例
thread-pool:
# 核心配置
core-pool-size: 10 # 核心线程数
max-pool-size: 50 # 最大线程数
queue-capacity: 100 # 队列容量
# 超时配置
keep-alive-seconds: 60 # 线程空闲时间
allow-core-thread-timeout: true # 允许核心线程超时
# 拒绝策略
rejection-policy: CALLER_RUNS_POLICY # 拒绝策略
# 可选: ABORT_POLICY, CALLER_RUNS_POLICY, DISCARD_OLDEST_POLICY, DISCARD_POLICY
# 线程配置
thread-name-prefix: "async-task-" # 线程名称前缀
thread-priority: 5 # 线程优先级
daemon: false # 是否守护线程
# 关闭配置
wait-for-tasks-to-complete: true # 等待任务完成
await-termination-seconds: 60 # 等待终止时间
B. 性能测试模板
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
/**
* 对象池性能测试
*/
class ObjectPoolBenchmark {
public static void main(String[] args) throws Exception {
int threadCount = 50;
int operationsPerThread = 10000;
// 测试传统创建
benchmarkTraditionalCreation(threadCount, operationsPerThread);
// 测试对象池
benchmarkObjectPool(threadCount, operationsPerThread);
}
/**
* 测试传统创建方式
*/
private static void benchmarkTraditionalCreation(int threadCount,
int operationsPerThread) throws Exception {
System.out.println("=== Benchmarking Traditional Creation ===");
ExecutorService executor = Executors.newFixedThreadPool(threadCount);
CountDownLatch latch = new CountDownLatch(threadCount);
AtomicLong totalTime = new AtomicLong(0);
long startTime = System.nanoTime();
for (int i = 0; i < threadCount; i++) {
executor.submit(() -> {
long threadStart = System.nanoTime();
for (int j = 0; j < operationsPerThread; j++) {
// 传统方式：每次创建新对象
StringBuilder sb = new StringBuilder();
sb.append("test");
sb.toString();
}
long threadEnd = System.nanoTime();
totalTime.addAndGet(threadEnd - threadStart);
latch.countDown();
});
}
latch.await();
long endTime = System.nanoTime();
executor.shutdown();
long totalDuration = endTime - startTime;
System.out.println("Total Duration: " + (totalDuration / 1_000_000) + " ms");
System.out.println("Avg Duration per Thread: " +
(totalTime.get() / threadCount / 1_000_000) + " ms");
System.out.println("Operations: " + (threadCount * operationsPerThread));
System.out.println("Ops/Second: " +
(threadCount * operationsPerThread * 1_000_000_000L / totalDuration));
}
/**
* 测试对象池方式
*/
private static void benchmarkObjectPool(int threadCount,
int operationsPerThread) throws Exception {
System.out.println("\n=== Benchmarking Object Pool ===");
ObjectPool<StringBuilder> pool = new SimpleObjectPool<>(
StringBuilder::new,
10, // minIdle
100 // maxTotal
);
ExecutorService executor = Executors.newFixedThreadPool(threadCount);
CountDownLatch latch = new CountDownLatch(threadCount);
AtomicLong totalTime = new AtomicLong(0);
long startTime = System.nanoTime();
for (int i = 0; i < threadCount; i++) {
executor.submit(() -> {
long threadStart = System.nanoTime();
for (int j = 0; j < operationsPerThread; j++) {
try {
// 对象池方式：从池中获取
StringBuilder sb = pool.borrowObject();
sb.setLength(0);
sb.append("test");
sb.toString();
pool.returnObject(sb);
} catch (Exception e) {
e.printStackTrace();
}
}
long threadEnd = System.nanoTime();
totalTime.addAndGet(threadEnd - threadStart);
latch.countDown();
});
}
latch.await();
long endTime = System.nanoTime();
executor.shutdown();
long totalDuration = endTime - startTime;
System.out.println("Total Duration: " + (totalDuration / 1_000_000) + " ms");
System.out.println("Avg Duration per Thread: " +
(totalTime.get() / threadCount / 1_000_000) + " ms");
System.out.println("Operations: " + (threadCount * operationsPerThread));
System.out.println("Ops/Second: " +
(threadCount * operationsPerThread * 1_000_000_000L / totalDuration));
// 计算性能提升
System.out.println("\n=== Performance Improvement ===");
long traditionalTime = 0; // 从上面的测试获取
long poolTime = totalDuration;
double improvement = (double)(traditionalTime - poolTime) / traditionalTime * 100;
System.out.println("Improvement: " + String.format("%.2f%%", improvement));
}
}
C. 故障排查清单
对象池故障排查清单
==================
1. 池耗尽问题
✓ 检查池大小配置是否合理
✓ 检查是否有对象未正确归还
✓ 检查对象创建时间是否过长
✓ 检查是否有对象泄漏
✓ 增加监控日志，跟踪对象使用情况
2. 性能问题
✓ 检查对象获取/归还的耗时
✓ 检查锁竞争情况
✓ 检查对象验证逻辑是否过于复杂
✓ 考虑使用线程本地池减少竞争
✓ 检查对象重置逻辑是否高效
3. 内存问题
✓ 检查池大小是否过大
✓ 检查是否有内存泄漏
✓ 检查对象清理逻辑是否正确
✓ 使用内存分析工具分析堆内存
✓ 检查对象生命周期管理
4. 对象状态问题
✓ 检查对象重置逻辑是否完整
✓ 检查对象验证逻辑是否正确
✓ 检查对象是否线程安全
✓ 检查对象状态是否被正确清理
✓ 增加状态验证日志
5. 并发问题
✓ 检查锁的使用是否正确
✓ 检查是否有死锁风险
✓ 检查条件变量的使用是否正确
✓ 检查原子操作的使用是否合适
✓ 使用并发分析工具检查竞争条件
6. 配置问题
✓ 检查池大小配置是否合理
✓ 检查超时配置是否合适
✓ 检查验证配置是否正确
✓ 检查清理策略配置是否合理
✓ 检查扩容/收缩策略是否合适
扫一扫
3963
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
