对象池是一种设计模式，用于管理和重用对象，以提高性能和资源利用率。对象池的概念在许多应用程序中都有广泛应用，特别是在需要频繁创建和销毁对象的情况下，例如数据库连接、线程、HTTP连接等

对象池通过预先创建一组对象并将它们存储在池中，以供需要时获取和使用。当对象不再需要时，它们不会被销毁，而是被返回到池中，以便在后续的请求中重新使用

对象池的优点包括：

• 减少对象创建和销毁的开销，提高性能和响应时间
• 最大限度地利用系统资源，避免资源的浪费
• 控制对象的数量，防止资源耗尽和系统崩溃
• 提供对象的重用机制，避免频繁的对象创建和垃圾回收

Apache Commons Pool2

Apache Commons Pool2 是一个广泛使用的Java对象池库，被许多开源项目和企业应用程序采用。它提供了通用的对象池化解决方案，可用于管理各种类型的对象，如数据库连接、线程池、HTTP连接等

Commons Pool 工作原理

核心类

ObjectPool

对象池，负责对对象进行生命周期的管理，并提供了对对象池中活跃对象和空闲对象统计的功能

• 对象的提供与归还：borrowObject、returnObject
• 创建对象：addObject
• 销毁对象：invalidateObject
• 池中空闲对象数量、被使用对象数量：getNumActive、getNumIdle

PooledObjectFactory

对象工厂类，负责具体对象的创建、初始化，对象状态的销毁和验证

commons-pool2框架本身提供了默认的抽象实现BasePooledObjectFactory，业务方在使用的时候只需要继承该类，然后实现warp和create方法即可

PooledObject

池化对象，是需要放到ObjectPool对象的一个包装类。添加了一些附加的信息，比如说状态信息，创建时间，激活时间等

池对象状态及流程

PooledObjectState 池对象状态枚举

public enum PooledObjectState {
    //在空闲队列中,还未被使用
    IDLE,
    //使用中
    ALLOCATED,
    //在空闲队列中,当前正在测试是否满足被驱逐的条件
    EVICTION,
	  //不在空闲队列中，目前正在测试是否可能被驱逐。因为在测试过程中，试图借用对象，并将其从队列中删除。
    //回收测试完成后，它应该被返回到队列的头部。
    EVICTION_RETURN_TO_HEAD,
	  //在队列中，正在被校验
    VALIDATION,
	  //不在队列中，当前正在验证。该对象在验证时被借用，由于配置了testOnBorrow，
    //所以将其从队列中删除并预先分配。一旦验证完成，就应该分配它。
    VALIDATION_PREALLOCATED,
	  //不在队列中，当前正在验证。在之前测试是否将该对象从队列中移除时，曾尝试借用该对象。
    //一旦验证完成，它应该被返回到队列的头部。
    VALIDATION_RETURN_TO_HEAD,
	  //无效状态(如驱逐测试或验证)，并将/已被销毁
    INVALID,
	  //判定为无效,将会被设置为废弃
    ABANDONED,
	  //正在使用完毕,返回池中
    RETURNING
}

流程理解

此段原文自 https://www.cnblogs.com/haixiang/p/14783955.html

对象存储

 private PooledObject<T> create() throws Exception {
  		.....
 		final PooledObject<T> p;
        try {
            p = factory.makeObject();
        .....
        allObjects.put(new IdentityWrapper<>(p.getObject()), p);
        return p;
 }

我们查看allObjects，所有对象都存储于ConcurrentHashMap，除了被杀掉的对象

/*
 * All of the objects currently associated with this pool in any state. It
 * excludes objects that have been destroyed. The size of
 * {@link #allObjects} will always be less than or equal to {@link
 * #_maxActive}. Map keys are pooled objects, values are the PooledObject
 * wrappers used internally by the pool.
 */
private final Map<IdentityWrapper<T>, PooledObject<T>> allObjects =
    new ConcurrentHashMap<>();

对象取用逻辑

• 首先根据AbandonedConfig配置判断是否取用对象前执行清理操作
• 再从idleObject中尝试获取对象，获取不到就创建新的对象
  • 判断blockWhenExhausted是否设置为true，是的话按照设置的borrowMaxWaitMillis属性等待可用对象(这个配置的意思是当对象池的active状态的对象数量已经达到最大值maxinum时是否进行阻塞直到有空闲对象)
• 有可用对象后调用工厂的factory.activateObject方法激活对象
• 当getTestOnBorrow设置为true时，调用factory.validateObject(p)对对象进行校验，通过校验后执行下一步
• 调用updateStatsBorrow方法，在对象被成功借出后更新一些统计项，例如返回对象池的对象个数等

//....
private final LinkedBlockingDeque<PooledObject<T>> idleObjects;
//....
public T borrowObject(final long borrowMaxWaitMillis) throws Exception {
        assertOpen();
        final AbandonedConfig ac = this.abandonedConfig;
        if (ac != null && ac.getRemoveAbandonedOnBorrow() &&
                (getNumIdle() < 2) &&
                (getNumActive() > getMaxTotal() - 3) ) {
            removeAbandoned(ac);
        }
        PooledObject<T> p = null;
        // Get local copy of current config so it is consistent for entire
        // method execution
        final boolean blockWhenExhausted = getBlockWhenExhausted();
        boolean create;
        final long waitTime = System.currentTimeMillis();
        while (p == null) {
            create = false;
            p = idleObjects.pollFirst();
            if (p == null) {
                p = create();
                if (p != null) {
                    create = true;
                }
            }
            if (blockWhenExhausted) {
                if (p == null) {
                    if (borrowMaxWaitMillis < 0) {
                        p = idleObjects.takeFirst();
                    } else {
                        p = idleObjects.pollFirst(borrowMaxWaitMillis,
                                TimeUnit.MILLISECONDS);
                    }
                }
                if (p == null) {
                    throw new NoSuchElementException(
                            "Timeout waiting for idle object");
                }
            } else {
                if (p == null) {
                    throw new NoSuchElementException("Pool exhausted");
                }
            }
            if (!p.allocate()) {
                p = null;
            }
            if (p != null) {
                try {
                    factory.activateObject(p);
                } catch (final Exception e) {
                    try {
                        destroy(p, DestroyMode.NORMAL);
                    } catch (final Exception e1) {
                        // Ignore - activation failure is more important
                    }
                    p = null;
                    if (create) {
                        final NoSuchElementException nsee = new NoSuchElementException(
                                "Unable to activate object");
                        nsee.initCause(e);
                        throw nsee;
                    }
                }
                if (p != null && getTestOnBorrow()) {
                    boolean validate = false;
                    Throwable validationThrowable = null;
                    try {
                        validate = factory.validateObject(p);
                    } catch (final Throwable t) {
                        PoolUtils.checkRethrow(t);
                        validationThrowable = t;
                    }
                    if (!validate) {
                        try {
                            destroy(p, DestroyMode.NORMAL);
                            destroyedByBorrowValidationCount.incrementAndGet();
                        } catch (final Exception e) {
                            // Ignore - validation failure is more important
                        }
                        p = null;
                        if (create) {
                            final NoSuchElementException nsee = new NoSuchElementException(
                                    "Unable to validate object");
                            nsee.initCause(validationThrowable);
                            throw nsee;
                        }
                    }
                }
            }
        }
        updateStatsBorrow(p, System.currentTimeMillis() - waitTime);
        return p.getObject();
    }

对象的激活和钝化

在对象使用完被返回对象池时，如果校验失败直接销毁，如果校验通过需要先钝化对象passivateObject(PooledObject<T> p)再存入空闲队列。至于激活对象的方法activateObject(PooledObject<T> p)在上述取用对象时也会先激活再被取出。因此我们可以发现处于空闲和使用中的对象他们除了状态不一致，我们也可以通过激活和钝化的方式在他们之间增加新的差异

例如我们要做一个Elasticsearch连接池，每个对象就是一个带有ip和端口的连接实例，很显然访问es集群是多个不同的ip，所以每次访问的ip不一定相同，我们则可以在激活操作为对象赋值ip和端口，钝化操作中将ip和端口归为默认值或者空，这样流程更为标准

对象回收机制

EvictionTimer为回收对象的定时器，当且仅当设置了timeBetweenEvictionRunsMillis参数后才会开启定时清理任务

对象状态为evict，直接调用destroy进行回收。否则会进行进一步地处理，逻辑如下：

1. 尝试激活对象，如果激活失败则认为对象已经不再存活，直接调用destroy进行销毁
2. 在激活对象成功的情况下，会通过validateObject方法取校验对象状态，如果校验失败，则说明对象不可用，需要进行销毁

// org.apache.commons.pool2.impl.GenericObjectPool#evict
if (evict) {
    destroy(underTest);
    destroyedByEvictorCount.incrementAndGet();
} else {
    if (testWhileIdle) {
        boolean active = false;
        try {
            factory.activateObject(underTest);
            active = true;
        } catch (Exception e) {
            destroy(underTest);
            destroyedByEvictorCount.incrementAndGet();
        }
        if (active) {
            if (!factory.validateObject(underTest)) {
                destroy(underTest);
                destroyedByEvictorCount.incrementAndGet();
            } else {
                try {
                    factory.passivateObject(underTest);
                } catch (Exception e) {
                    destroy(underTest);
                    destroyedByEvictorCount.incrementAndGet();
                }
            }
        }
    }
    if (!underTest.endEvictionTest(idleObjects)) {
        // TODO - May need to add code here once additional
        // states are used
    }
}

常用参数详解

参数	类型（默认值）	描述
lifo	boolean（true）	当去获取对象池中的空闲实例时，是否需要遵循后进先出的原则
fairness	boolean（false）	当对象池处于exhausted状态，即可用实例为空时，大量线程在同时阻塞等待获取可用的实例，fairness配置来控制是否启用公平锁算法，即先到先得。这一项的前提是blockWhenExhausted配置为true
maxTotal	int（8）	对象池中最大使用数量
maxIdle	int（8）	对象中空闲对象最大数量
minIdle	int（0）	对象池中空闲对象最小数量
maxWaitMillis	long（-1）	最大阻塞时间，当对象池处于exhausted状态，即可用实例为空时，大量线程在同时阻塞等待获取可用的实例，如果阻塞时间超过了maxWaitMillis将会抛出异常
testOnCreate	boolean（false）	创建对象前，是否校验该新对象的有效性
testOnBorrow	boolean（false）	取用对象前，是否检验对象的有效性
testOnReturn	boolean（false）	归还对象前，是否检验对象的有效性
testWhileIdle	boolean（false）	当回收器在扫描空闲对象时，是否校验对象的有效性
numTestsPerEvictionRun	int（3）	根据该值x可以推导出一个数值n，标识回收过程需要检查多少个空闲对象。如果x>=0，那么n=x。如果x<0，那么n=（空闲对象数量/x的绝对值）向上取整，假设空闲对象一共有10个，该值配置为-3，那么就意味着这次回收需要检查4个空闲对象
timeBetweenEvictionRunsMillis	long（-1）	回收器线程多久执行一次空闲对象回收
softMinEvictableIdleTimeMillis	long（-1）	软回收时间阈值一个对象如果空闲时间超过了该值（毫秒），并且空闲对象的数量已经大于了minIdle时，就可以被回收器回收
minEvictableIdleTimeMillis	long（1000L * 60L * 30L）	硬回收时间阈值一个对象如果空闲时间超过了该值，即使空闲对象的数量已经小于minIdle了，一样也会被回收器回收

假如在某个高负载的系统里，对象频繁被借出、被归还。此时推荐对象池配置为

1. testOnBorrow、testOnReturn都设置为false，提升性能
2. timeBetweenEvictionRunsMillis设置为60000，一分钟进行一次空闲对象的回收检查
3. numTestsPerEvictionRun设置为-1，检查所有空闲对象
4. minEvictableIdleTimeMillis设置为180000，空闲超过3分钟的可以被回收
5. testWhileIdle设置为true，不管空闲时间是否超时，每个空闲对象都检查下有效性，无效的一样被回收

通过异步的回收器来尽可能的保证空闲对象的有效性，减少同步调用时有效性检查导致的响应延迟、以及有效性检查对底层带来的访问压力

总结

Apache Commons Pool2是一个用于对象池化的Java库，它提供了一种管理和重用对象实例的机制，旨在改善应用程序的性能和资源利用率。下面是对Apache Commons Pool2的总结：

• 对象池化：Apache Commons Pool2允许您创建和管理一个对象池，该对象池中保存着可重用的对象实例。通过将对象保存在池中而不是频繁地创建和销毁对象，可以减少系统开销，提高性能。
• 对象生命周期管理：Pool2提供了生命周期管理功能，允许您定义在对象从池中借出和归还时的初始化和清理操作。这确保了从池中借出的对象始终处于一种可用状态。
• 池化策略：Pool2支持多种池化策略，如通用对象池、软引用对象池和弱引用对象池。您可以根据应用程序的需求选择适合的策略。
• 线程安全：Pool2是线程安全的，它提供了同步机制来处理多个线程同时访问池的情况，确保对象的正确分配和归还。
• 配置灵活：Pool2允许您通过配置文件或编程方式来配置对象池的各种属性，如最大池大小、最小空闲对象数、池中对象的最大空闲时间等。这使得您可以根据应用程序的需求进行优化和调整。
• 连接池和资源池：Pool2不仅适用于对象池，还可用于连接池和其他资源的池化管理。这使得它在处理数据库连接、线程池等资源时非常有用。

总的来说，Apache Commons Pool2是一个功能强大且灵活的对象池化库，可帮助您管理和重用对象实例，提高应用程序的性能和资源利用率。无论是在Web应用程序、并发编程还是资源管理方面，Pool2都是一个可靠的选择

---

参考资料：

1. Apache Commons Pool
2. commons-pool2 池化技术探究
3. 对象池
4. apache common pool2原理与实战