<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.11.1</version>
</dependency>
在Java应用程序中，频繁地创建和销毁对象会消耗大量的内存和CPU资源，影响应用程序的性能和可伸缩性。为了解决这个问题，我们可以使用对象池技术，将对象存储在池中，在需要的时候从池中获取，使用完毕后将对象归还到池中。Apache Commons Pool2是一个流行的开源对象池实现，提供了丰富的功能和配置选项，可以满足不同应用程序的需求。
Commons Pool2是一个流行的开源对象池实现，提供了丰富的接口和配置选项，使得实现对象池变得非常容易，并且可以根据具体的业务需求进行灵活的配置。Commons Pool2还支持多线程共享对象池中的对象，避免线程之间的竞争，从而提高应用程序的并发性能。
链接池/对象池(ObjectPool):用于存放链接对象的一个池子(集合),通常用数组或者List对象.durid用两个数组分别保存活跃的链接和空闲链接.commons-pool2用双端阻塞队列LinkedBlockingDeque保存空闲链接
用ConcurrentHashMap保存所有的链接.
对象工厂(PooledObjectFactory):连接池工厂，用于产生一个新的链接对象.
链接对象/池中对象(PooledObject):链接池里面存放的对象.
// 自定义的资源类
public class MyObject {
LocalTime time;
public String id;
int seq = 0;
public MyObject(String id){
this.id = id;
time = LocalTime.now();
}
public void cry(){
System.out.println(time + "cry "+ seq++);
this.hashCode();
}
public boolean isOk(){
return this.seq ?< 2;
}
}
// 自定义的资源对象的 key,用于区分资源类
public class MyKey {
public String key ;
public MyKey(String key){
this.key = key;
}
@Override
public int hashCode(){
return (this.key).hashCode();
}
}
public class MyObjectPool {
@Getter
private final GenericKeyedObjectPool<MyKey,MyObject> pool;
public MyObjectPool() {
GenericKeyedObjectPoolConfig<MyObject> config = new GenericKeyedObjectPoolConfig<>();
// 最大资源数
config.setMaxTotal(1);
// 每个 key 对应的最大资源数
config.setMaxTotalPerKey(1);
// 最大 key 数量
config.setMaxIdlePerKey(1);
// 没有可用资源时是否要等待
config.setBlockWhenExhausted(true);
// 创建新资源对象后是否立即校验是否可用
config.setTestOnCreate(false);
// 借用资源对象前是否校验是否可用
config.setTestOnBorrow(true);
KeyedPooledObjectFactory<MyKey , MyObject> factory = new MyPooledObjectFactory();
this.pool = new GenericKeyedObjectPool<>(factory, config);
}
}
// 自定义 Factory 类，实现了 apache 的接口，用于管理资源类
public class MyPooledObjectFactory implements KeyedPooledObjectFactory<MyKey ,MyObject> {
@Override
public void activateObject(MyKey s, PooledObject<MyObject> pooledObject) throws Exception {
System.out.println("激活对象，借用时调用");
}
@Override
public void destroyObject(MyKey s, PooledObject<MyObject> pooledObject) throws Exception {
System.out.println("销毁对象");
}
@Override
public PooledObject<MyObject> makeObject(MyKey s) throws Exception {
System.out.println("创建对象");
MyObject object = new MyObject(s.key);
return new DefaultPooledObject(object);
}
// “钝化:就是序列化,把对象转化为字节序列,把Session对象从内存保存到硬盘里。
// 活化:就是反序列化,把字节序列转化为对象,把Session对象从硬盘再读回内存。
@Override
public void passivateObject(MyKey s, PooledObject<MyObject> pooledObject) throws Exception {
System.out.println("钝化对象，归还时调用");
}
@Override
public boolean validateObject(MyKey s, PooledObject<MyObject> pooledObject) {
System.out.println("判断对象是否可用");
return pooledObject.getObject().isOk();
}
}
public class MyTest {
public static void main(String[] args) throws Exception {
MyObjectPool myObjectPool = new MyObjectPool();
GenericKeyedObjectPool<MyKey , MyObject> pool ?= myObjectPool.getPool();
MyKey key = new MyKey("1");
for(int i=0;i<3;i++){
MyObject myObject = pool.borrowObject(key);
myObject.cry();
pool.returnObject(key,myObject);
System.out.println(" ???");
}
}
}