GenericObjectPool对象池

概要

GenericObjectPool是一个通用对象池框架。线程安全的。

当我们频繁创建、销毁一个对象，或考虑对象服用时，它就能解决你的问题

GenericObjectPool

GenericObjectPool是一个通用的对象池框架。

创建时需要传入PooledObjectFactory,PooledObjectFactory内提供了维修对象池的API。

public interface PooledObjectFactory<T> {
    //创建对象
    PooledObject<T> makeObject() throws Exception;
    //销毁对象
    void destroyObject(PooledObject<T> var1) throws Exception;
    //从池中取对象或归还对象到池中时，判断对象安全
    boolean validateObject(PooledObject<T> var1);
    //从池中取出对象，使用前，再次初始化对象
    void activateObject(PooledObject<T> var1) throws Exception;
    //当对象返回到空闲池时调用，钝化对象
    void passivateObject(PooledObject<T> var1) throws Exception;
}

GenericObjectPoolConfig

基本参数

1. GenericObjectPool 提供了后进先出(LIFO)与先进先出(FIFO)两种行为模式的池。默认为true，即当池中有空闲可用的对象时，调用borrowObject方法会返回最近（后进）的实例
2. 当从池中获取资源或者将资源还回池中时 是否使用java.util.concurrent.locks.ReentrantLock.ReentrantLock 的公平锁机制,默认为false

控制参数

对象池配置，包含最大对象数、最大空闲对象数、最小空闲对象数等配置，示例如下：

//创建对象池配置
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
//最大连接数
config.setMaxTotal(6);
//最大空闲数
config.setMaxIdle(3);
//最小空闲数
config.setMinIdle(1);
//最长等待时间，3秒
//当连接池资源耗尽时，等待时间，超出则抛异常，默认为-1即永不超时 。需要和blockWhenExhausted配合使用
config.setMaxWaitMillis(3000);

依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.8.0</version>
</dependency>

DEMO代码

public abstract class Pool<T> implements Closeable {
    protected GenericObjectPool<T> internalPool;
    public Pool() {
    }
    public Pool(final GenericObjectPoolConfig poolConfig, PooledObjectFactory<T> factory) {
        initPool(poolConfig, factory);
    }
    public Pool(PooledObjectFactory<T> factory) {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMinIdle(2);
        poolConfig.setMaxIdle(5);
        poolConfig.setMaxTotal(5);
        poolConfig.setMaxWaitMillis(10000);
        initPool(poolConfig, factory);
    }
    @Override
    public void close() {
        destroy();
    }
    public boolean isClosed() {
        return this.internalPool.isClosed();
    }
    public void initPool(final GenericObjectPoolConfig poolConfig, PooledObjectFactory<T> factory) {
        if (this.internalPool != null) {
            try {
                closeInternalPool();
            } catch (Exception e) {
            }
        }
        this.internalPool = new GenericObjectPool<T>(factory, poolConfig);
    }
    public T getResource() {
        try {
            return internalPool.borrowObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    protected void returnResourceObject(final T resource) {
        if (resource == null) {
            return;
        }
        try {
            internalPool.returnObject(resource);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    protected void returnBrokenResource(final T resource) {
        if (resource != null) {
            returnBrokenResourceObject(resource);
        }
    }
    protected void returnResource(final T resource) {
        if (resource != null) {
            returnResourceObject(resource);
        }
    }
    public void destroy() {
        closeInternalPool();
    }
    protected void returnBrokenResourceObject(final T resource) {
        try {
            internalPool.invalidateObject(resource);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    protected void closeInternalPool() {
        try {
            internalPool.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public int getNumActive() {
        if (poolInactive()) {
            return -1;
        }
        return this.internalPool.getNumActive();
    }
    public int getNumIdle() {
        if (poolInactive()) {
            return -1;
        }
        return this.internalPool.getNumIdle();
    }
    public int getNumWaiters() {
        if (poolInactive()) {
            return -1;
        }
        return this.internalPool.getNumWaiters();
    }
    public long getMeanBorrowWaitTimeMillis() {
        if (poolInactive()) {
            return -1;
        }
        return this.internalPool.getMeanBorrowWaitTimeMillis();
    }
    public long getMaxBorrowWaitTimeMillis() {
        if (poolInactive()) {
            return -1;
        }
        return this.internalPool.getMaxBorrowWaitTimeMillis();
    }
    private boolean poolInactive() {
        return this.internalPool == null || this.internalPool.isClosed();
    }
    public void addObjects(int count) {
        try {
            for (int i = 0; i < count; i++) {
                this.internalPool.addObject();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class WebDriverPool extends Pool<ChromeDriver> {
    public WebDriverPool() {
        super(new WebDriverFactory());
    }
    public WebDriverPool(GenericObjectPoolConfig poolConfig, PooledObjectFactory<ChromeDriver> factory) {
        super(poolConfig, factory);
    }
    @Override
    public void returnResource(ChromeDriver resource) {
        super.returnResource(resource);
    }
}

public class WebDriverFactory implements PooledObjectFactory<ChromeDriver> {
    @Override
    public PooledObject<ChromeDriver> makeObject() {
        return new DefaultPooledObject<>(ChromeDriverUtil.getSimpleDriver());
    }
    @Override
    public void destroyObject(PooledObject<ChromeDriver> pooledObject) throws Exception {
        pooledObject.getObject().quit();
    }
    @Override
    public boolean validateObject(PooledObject<ChromeDriver> pooledObject) {
        boolean flag = false;
        ChromeDriver driver = pooledObject.getObject();
        if (driver != null) {
            flag = true;
        }
        return flag;
    }
    @Override
    public void activateObject(PooledObject<ChromeDriver> pooledObject) throws Exception {
    }
    @Override
    public void passivateObject(PooledObject<ChromeDriver> pooledObject) throws Exception {
    }
}