apache-common-pool2对象池的使用

作者: 疯狂的哈丘 | 来源:发表于2018-07-14 12:00 被阅读0次

Common-pool2使用
apache-common-pool2对象池的使用
Laya_2D示例项目使用对象池预制体的创建、位置设置和添加到父
ARC自动引用计数和分类
TS:对象池
Netty对象池
微信小游戏性能优化点
creator使用对象池
对象池的使用实现
对象池模式的使用

一、概述

大多时候，我们获取对象的方法都是直接new一个。但是，对于大对象的构造，或者构造耗时比较久的对象，我们每次要使用都去new一个是很不科学的。比如数据库的连接对象、redis的连接对象、Http连接请求对象等等。在设计模式中有一个专门的模式来解决这种场景下的问题，即享元模式。

享元模式其实很好理解，也就是构造一个对象池，这个对象池中维护一定数量的对象，需要的时候就从这个对象池中获取对象，使用完后返还给对象池。这样就避免构造对象所带来的耗时，提升了系统的性能。

设计这样的一个对象池看起来好像并不难，甚至觉的只需要一个List就可以做到。但是，如果考虑到系统的伸缩性，比如在系统忙时可能需要对象池中有足够的对象可以被拿来使用，以保证系统大多时候应该等待对象而进入阻塞，同时，在系统闲时又不需要太多的对象存放在对象池中，这时候就需要释放一些对象。另外，还需要考虑对象何时构造，何时销毁，对象异常的处理等问题。

为了让大多java程序员不重复造轮子，apache开发了一个库，专门给需要对象池的程序提供一个底层的支持。这个库也就是apche-common-pool2，使用这个库，我们只需要关注对象的生成、销毁、校验等操作就可以了。对象池的具体实现细节都交给common-pool2中的具体对象池实现类来完成。

二、maven地址

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.4.2</version>
</dependency>

三、相关接口

common-pool2下有几个很重要的接口，common-pool2也是以这几个接口为基础进行开发的。
ObjectPool.java，抽象了对象池的一个整体的行为。

    //从对象池中获取对象的方法
    T borrowObject() throws Exception, NoSuchElementException,
            IllegalStateException;
    //将对象返还给对象池
    void returnObject(T obj) throws Exception;
    //让对象失效
    void invalidateObject(T obj) throws Exception;
    //往对象池中新增一个对象
    void addObject() throws Exception, IllegalStateException,
            UnsupportedOperationException;
    //获取当前闲置在对象池中的对象数量，即没有被拿走使用的对象数量
    int getNumIdle();
    //获取已经在使用中的对象数量，即被使用者从对象池中拿走使用的数量
    int getNumActive();
    //清空对象池中闲置的所有对象
    void clear() throws Exception, UnsupportedOperationException;
    //关闭对象池
    void close();

PooledObject,抽象了对象池中对象应该具备的一些属性。注意，这个对象并不是我们真正要存的对象，而是经过一层封装的对象。比如我们想往对象池存放String类型的对象，那么真正存放在对象池的其实都是经过封装过的对象，即PooledObject<String>对象。

public interface PooledObject<T> extends Comparable<PooledObject<T>> {
    T getObject();
    long getCreateTime();
    long getActiveTimeMillis();
    long getIdleTimeMillis();
    long getLastBorrowTime();
    long getLastReturnTime();
    long getLastUsedTime();
    @Override
    int compareTo(PooledObject<T> other);
    @Override
    boolean equals(Object obj);
    @Override
    int hashCode();
    String toString();
    boolean startEvictionTest();
    boolean endEvictionTest(Deque<PooledObject<T>> idleQueue);
    boolean allocate();
    boolean deallocate();
    void invalidate();
    void setLogAbandoned(boolean logAbandoned);
    void use();
    void printStackTrace(PrintWriter writer);
    PooledObjectState getState();
    void markAbandoned();
    void markReturning();
}

PooledObjectFactory.java，抽象了生成对象的工厂模型

public interface PooledObjectFactory<T> {
  //构造一个封装对象
  PooledObject<T> makeObject() throws Exception;
  //销毁对象
  void destroyObject(PooledObject<T> p) throws Exception;
  //验证对象是否可用
  boolean validateObject(PooledObject<T> p);
  //激活一个对象，使其可用用
  void activateObject(PooledObject<T> p) throws Exception;
   //钝化一个对象,也可以理解为反初始化
  void passivateObject(PooledObject<T> p) throws Exception;
}

同时还有KeyedObjectPool,KeyedPooledObjectFactory接口，主要提供了带有键的对象池模板。带有键的对象池可以理解为一个 Map<key,ObjectPool> 。也就是每个键都对应一个对象池。

四、常规对象池的使用

下面举个例子，假设我们要做一个维护数据库连接的对象池。我们只需要定义两个类
DbConnection,用于连接数据库的对象。为了让代码不那么复杂，下面的类并没有连接数据库的代码，只有一个简单的属性，表示是否连接上数据库。

public class DbConnection {

    private Boolean isActive;

    public Boolean getActive() {
        return isActive;
    }

    public void setActive(Boolean active) {
        isActive = active;
    }
}

再定义一个构造DbConnection的工厂类DbConnectionFactory,然后实现一些方法

public class DbConnectionFactory implements PooledObjectFactory<DbConnection> {

    @Override
    public PooledObject<DbConnection> makeObject() throws Exception {
        DbConnection dbConnection = new DbConnection();
        //构造一个新的连接对象
        return new DefaultPooledObject<>(dbConnection);
    }

    @Override
    public void destroyObject(PooledObject<DbConnection> p) throws Exception {
        //断开连接
        p.getObject().setActive(false);
    }

    @Override
    public boolean validateObject(PooledObject<DbConnection> p) {
        //判断这个对象是否是保持连接状态
        return p.getObject().getActive();
    }

    @Override
    public void activateObject(PooledObject<DbConnection> p) throws Exception {
        //激活这个对象，让它连接上数据库
        p.getObject().setActive(true);
    }

    @Override
    public void passivateObject(PooledObject<DbConnection> p) throws Exception {
        //不处理
    }
}

到这里，我们就可以使用common-pool2自带的GenericObjectPool类了。

public static void main(String[] args) {
        DbConnectionFactory factory = new DbConnectionFactory();
        //设置对象池的相关参数
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxIdle(20);
        poolConfig.setMaxTotal(100);
        poolConfig.setMinIdle(5);
        //新建一个对象池,传入对象工厂和配置
        GenericObjectPool<DbConnection> objectPool = new GenericObjectPool<>(factory, poolConfig);
        DbConnection dbConnection = null;
        try {
            //从对象池获取对象，如果
            dbConnection = objectPool.borrowObject();
            System.out.println(dbConnection.getActive());
            //使用改对象
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dbConnection != null) {
                //返还对象
                objectPool.returnObject(dbConnection);
            }
        }
    }

这样，我们就已经完成的常规对象池的所有开发。

SoftReferenceObjectPool

common-pool2还提供了一个软引用对象池的实现类，原理和GenericObjectPool差不多，不过对象池中存放的封装对象是软引用对象。软引用对象主要是在堆空间不足会被GC回收，再具体的细节请读者自行百度。

五、带有键的对象池

目前我们看到的对象池的对象都是属于一个类型的，也就是说如果要求对象池中存放的对象类型不一样，常规对象池就做不到了。
比如现在有这样一个场景，项目中要连接的数据库比较多，每个数据库的地址账号密码都不一样，但是上面的常规对象池存放的连接对象好像没办法在取对象时指定获取哪个数据库的连接对象。这是，就需要带有键的对象池，也就是GenericKeyedObjectPool。

我们再定义个DbConnection2，多一个字段url，来表示属于哪个数据库的连接

public class DbConnection2 {

    private Boolean isActive;
    private String url;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public Boolean getActive() {
        return isActive;
    }

    public void setActive(Boolean active) {
        isActive = active;
    }
}

再实现一个KeyedPooledObjectFactory类

public class DbConnectionKeyFactory implements KeyedPooledObjectFactory<String, DbConnection2> {

    @Override
    public PooledObject<DbConnection2> makeObject(String key) throws Exception {
        DbConnection2 dbConnection2 = new DbConnection2();
        dbConnection2.setUrl(key);
        dbConnection2.setActive(true);
        return new DefaultPooledObject<>(dbConnection2);
    }

    @Override
    public void destroyObject(String key, PooledObject<DbConnection2> p) throws Exception {
        p.getObject().setActive(false);
    }

    @Override
    public boolean validateObject(String key, PooledObject<DbConnection2> p) {
        return p.getObject().getActive();
    }

    @Override
    public void activateObject(String key, PooledObject<DbConnection2> p) throws Exception {
        p.getObject().setActive(true);
    }

    @Override
    public void passivateObject(String key, PooledObject<DbConnection2> p) throws Exception {

    }
}

之后就可以使用GenericKeyedObjectPool对象池了

public static void main(String[] args) {
        GenericKeyedObjectPoolConfig genericKeyedObjectPoolConfig = new GenericKeyedObjectPoolConfig();
        genericKeyedObjectPoolConfig.setMaxIdlePerKey(10);
        genericKeyedObjectPoolConfig.setMaxTotalPerKey(100);
        genericKeyedObjectPoolConfig.setMaxTotal(500);
        genericKeyedObjectPoolConfig.setMinIdlePerKey(10);

        DbConnectionKeyFactory dbConnectionKeyFactory = new DbConnectionKeyFactory();
        GenericKeyedObjectPool<String, DbConnection2> genericKeyedObjectPool = new GenericKeyedObjectPool<>
                (dbConnectionKeyFactory, genericKeyedObjectPoolConfig);
        DbConnection2 dbConnection1 = null;
        DbConnection2 dbConnection2 = null;
        try {
            dbConnection1 = genericKeyedObjectPool.borrowObject("192.168.0.1");
            dbConnection2 = genericKeyedObjectPool.borrowObject("192.168.0.2");
            System.out.println(dbConnection1.getUrl());
            System.out.println(dbConnection2.getUrl());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dbConnection1 != null) {
                genericKeyedObjectPool.returnObject(dbConnection1.getUrl(), dbConnection1);
            }
            if (dbConnection2 != null) {
                genericKeyedObjectPool.returnObject(dbConnection2.getUrl(), dbConnection2);
            }
        }
    }

六、存放代理对象的对象池

如果需要在对象池中存放代理对象，common-pool2也提供了两个现有的对象池实现类ProxiedObjectPool和ProxiedKeyedObjectPool,我们下面简单介绍下ProxiedObjectPool的使用。
我们要用到jdk的对象代理机制，所以需要定义一个代表连接对象的接口类DbConnectionInterface

public interface DbConnectionInterface {
    public Boolean getActive();
    public void setActive(Boolean active);
}

之后定义一个实现类DbConnection

public class DbConnection implements DbConnectionInterface {

    private Boolean isActive;

    public Boolean getActive() {
        return isActive;
    }

    public void setActive(Boolean active) {
        isActive = active;
    }
}

为了方便观察代理的效果，我们需要再定义一下封装对象MyDefaultPooledObject,直接继承DefaultPooledObject类就好了。重写一下use()方法

public class MyDefaultPooledObject extends DefaultPooledObject<DbConnectionInterface> {
    public MyDefaultPooledObject(DbConnectionInterface object) {
        super(object);
    }

    @Override
    //代理对象被调用时，会回调这个方法
    public void use() {
        super.use();
        DbConnectionInterface object = getObject();
        System.out.println("method get " + object.getActive());
    }
}

最后还要定义一个生产DbConnectionInterface对象的工厂类DbConnectionFactory

public class DbConnectionFactory implements PooledObjectFactory<DbConnectionInterface> {

    @Override
    public PooledObject<DbConnectionInterface> makeObject() throws Exception {
        DbConnectionInterface dbConnection = new DbConnection();
        return new MyDefaultPooledObject(dbConnection);
    }

    @Override
    public void destroyObject(PooledObject<DbConnectionInterface> p) throws Exception {
        p.getObject().setActive(false);
    }

    @Override
    public boolean validateObject(PooledObject<DbConnectionInterface> p) {
        return p.getObject().getActive();
    }

    @Override
    public void activateObject(PooledObject<DbConnectionInterface> p) throws Exception {
        p.getObject().setActive(true);
    }

    @Override
    public void passivateObject(PooledObject<DbConnectionInterface> p) throws Exception {
        //不处理
    }
}

然后就可以开始使用ProxiedObjectPool对象池了

public static void main(String[] args) {
        DbConnectionFactory factory = new DbConnectionFactory();
        //这里必须定义一个AbandonedConfig配置，并且设置useUsageTracking属性为true
        //这样代理对象的方法被调用时，才会去调用DefaultPooledObject的use()方法
        AbandonedConfig abandonedConfig = new AbandonedConfig();
        abandonedConfig.setUseUsageTracking(true);
        //定义一个常规对象池
        GenericObjectPool<DbConnectionInterface> pool = new GenericObjectPool<>(factory, new GenericObjectPoolConfig()
                , abandonedConfig);
        pool.setMaxTotal(100); // 对象池中允许的最大对象数量
        pool.setMaxIdle(50);
        pool.setMaxWaitMillis(5000);
        pool.setTimeBetweenEvictionRunsMillis(10000);
        pool.setMinIdle(20);
        // 使用jdk自带的代理机制
        JdkProxySource<DbConnectionInterface> proxySource = new JdkProxySource<>(DbConnectionInterface.class
                .getClassLoader(), new
                Class[]{DbConnectionInterface.class});
        // 加装代理新对象池
        ProxiedObjectPool<DbConnectionInterface> proxiedPool = new ProxiedObjectPool<>(pool, proxySource);
        DbConnectionInterface connection = null;
        try {
            connection = proxiedPool.borrowObject();
            //每次代理对象被调用时，都会执行MyDefaultPooledObject里的use方法
            connection.getActive();
            //这里输出class com.sun.proxy.$Proxy0，说明这是一个代理对象
            System.out.println(connection.getClass());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                try {
                    proxiedPool.returnObject(connection);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }

这样，通过代理对象池取出的所有对象在调用方法时，都会经过我们定义的MyDefaultPooledObject#use()方法。

其实代理对象池的原理很简单,就是通过jdk的代理机制为刚创建的封装对象再创建一个代理对象，这样放到对象池中的就是代理对象了。当代理对象的任一方法被调用时，都会触发JdkProxyHandler#invoke()执行，也就是下面这个方法

@Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        return doInvoke(method, args);
    }

Object doInvoke(Method method, Object[] args) throws Throwable {
        validateProxiedObject();
        T object = getPooledObject();
        if (usageTracking != null) {
          //这里的usageTracking其实就是我们的常规对象池GenericObjectPool
          //GenericObjectPool实现了UsageTracking接口
            usageTracking.use(object);
        }
        return method.invoke(object, args);
    }

所以每个代理对象的方法调用都会触发GenericObjectPool#use()方法，use()方法里面会判断useUsageTracking是否开启来决定是否调用poolObject#use()方法。

@Override
    public void use(T pooledObject) {
        AbandonedConfig ac = this.abandonedConfig;
        if (ac != null && ac.getUseUsageTracking()) {
            PooledObject<T> wrapper = allObjects.get(new IdentityWrapper<T>(pooledObject));
            wrapper.use();
        }
    }

ProxiedKeyedObjectPool的原理也差不多，就不多做介绍了。

七、总结

总的来说，common-pool2给我们提供了5种不同类型的对象池实现来给我们使用:

GenericObjectPool
SoftReferenceObjectPool
GenericKeyedObjectPool
ProxiedObjectPool
ProxiedKeyedObjectPool

一般情况下，GenericObjectPool足够满足我们大部分的场景，而且用起来也很简单，我们只需要实现一个对象工厂类就可以了，可谓是开箱即用。另外SoftReferenceObjectPool和GenericKeyedObjectPool也有不少的使用场景，也很好用。

对于ProxiedObjectPool和ProxiedKeyedObjectPool，个人感觉并不太好用。因为代理对象只会在方法被调用前执行一些自定义方法，而没有在方法被调用后执行一些方法。另外，要开启代理对象池还需要专门设置AbandonedConfig，很是麻烦。可能还不如自己基于GenericObjectPool实现一个。当然，也可能是我理解不够，如果有不同意见的读者欢迎指出。

我的CSDN博客地址
https://blog.csdn.net/u013332124/article/details/81042375

Common-pool2使用
apache-common-pool2使用步骤 1、定义池保有类，该类实现PoolObject接口； 2、定义Fa...
apache-common-pool2对象池的使用
一、概述大多时候，我们获取对象的方法都是直接new一个。但是，对于大对象的构造，或者构造耗时比较久的对象，我们每...
Laya_2D示例项目使用对象池预制体的创建、位置设置和添加到父
//使用对象池创建盒子 1.对象池的使用对象池创建箱子 let box = Laya.Pool.getI...
ARC自动引用计数和分类
对象自动释放池的使用释放池的作用autorelease对象方法@autoreleasepool关键字的使用Pers...
TS:对象池
对象池项目源码：使用：
Netty对象池
在平时工作中,听说和使用过连接池,线程池等.还有一种就是对象池,可以实现对象复用的功能. 当然实现对象池的方式手段...
微信小游戏性能优化点
1. 对象池多数游戏，频繁创建和销毁同类对象很常见，使用对象池已是基本操作，必须牢记并熟练使用。推荐一个应用示例...
creator使用对象池
使用对象池在运行时进行节点的创建(cc.instantiate)和销毁(node.destroy)操作是非常耗费...
对象池的使用实现
MonoSingleton —— 单例基类任何继承自MonoSingleton泛型基类的脚本/类都是单例类 u...
对象池模式的使用
一、模式介绍对象池模式可以归类为创建型模式，是预先创建若干对象然后保存到内存对象池中，等到程序需要使用对象的时候...

apache-common-pool2对象池的使用

一、概述

二、maven地址

三、相关接口

四、常规对象池的使用

SoftReferenceObjectPool

五、带有键的对象池

六、存放代理对象的对象池

七、总结

相关文章

Common-pool2使用

apache-common-pool2对象池的使用

Laya_2D示例项目使用对象池预制体的创建、位置设置和添加到父

ARC自动引用计数和分类

TS:对象池

Netty对象池

微信小游戏性能优化点

creator使用对象池

对象池的使用实现

对象池模式的使用

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读