池技术之common-pool2

最新推荐文章于 2024-07-24 15:01:52 发布

chongcan0436

最新推荐文章于 2024-07-24 15:01:52 发布

阅读量649

点赞数

文章标签： java 数据库设计模式

原文链接：https://my.oschina.net/u/2391658/blog/3081238

版权

是什么

apache commons-pool是apache基金会的一个开源对象池组件，我们常用的数据库连接池dpcp和redis的java客户端jedis都使用commons-pool来管理连接

优化对象的创建,和设计模式中的享元模式思路一样

类解析
PooledObject 池化后的对象
ObjectPool 对象池,
PooledObjectFactory 池对象工厂
GenericObjectPool

实现了对对象池的管理，是一个基本的对象池实现
borrowObject 从对象池中获取一个对象
returnObject 对象使用完之后，归还到对象池

PooledObjectFactory

根据自己的业务创建和管理要对象池化的对象
makeObject 创建对象
destroyObject 销毁对象

对象的空闲时间(idle)超时
使用完被检测到对象已经无效时
当调用这个方法之后，对象的生命周期必须结束。如果是对象是线程，线程必须已结束，如果是socket，socket必须已close，如果是文件操作，文件数据必须已flush，且文件正常关闭.

validateObject 检测一个对象是否有效,无效会被销毁
activateObject 激活一个对象或者说启动对象的某些操作

检测空闲对象的时候,且设置了测试空闲对象是否可以用，就会调用这个方法.
borrowObject的时候
如果对象是一个包含参数的对象，可以在这里进行初始化

passivateObject 钝化对象
在向对象池归还一个对象是会调用这个方法。这里可以对对象做一些清理操作。比如清理掉过期的数据，下次获得对象时，不受旧数据的影响

一般来说activateObject和passivateObject是成对出现的。前者是在对象从对象池取出时做一些操作，后者是在对象归还到对象池做一些操作，可以根据自己的业务需要进行取舍。

参数配置类GenericObjectPoolConfig

lifo: 对象池存储空闲对象是使用的LinkedBlockingDeque,建议使用默认值true
fairness: 是否使用lock的公平锁(不公平的性能高5-10倍,获取锁时没排队,没有先到先得的概念)。默认值是false，建议使用默认值。
maxWaitMillis: 当没有空闲连接时，获取一个对象的最大等待时间。如果这个值小于0，则永不超时，一直等待，直到有空闲对象到来。如果大于0，则等待maxWaitMillis长时间，如果没有空闲对象，将抛出NoSuchElementException异常。默认值是-1；可以根据需要自己调整，单位是毫秒。
minEvictableIdleTimeMillis: 当空闲的时间大于这个值时，执行移除这个对象操作,默认值30分钟。这个参数是强制性的，只要空闲时间超过这个值，就会移除.小于0则为Long的最大值
softMinEvictableIdleTimeMillis: 对象最小的空闲时间 ,和minEvictableIdleTimeMillis逻辑一样,区别是:它会保留最小的空闲对象数量。而上面的不会，是强制性移除的。默认值是-1；
numTestsPerEvictionRun: 检测空闲对象线程每次检测的空闲对象的数量。默认值是3；如果这个值小于0,则每次检测的空闲对象数量等于当前空闲对象数量除以这个值的绝对值，并对结果向上取整

testOnCreate: 在创建对象时检测对象是否有效，true是，默认值是false。
testOnBorrow: 在从对象池获取对象时是否检测对象有效，true是；默认值是false。
testOnReturn: 在向对象池中归还对象时是否检测对象有效，true是，默认值是false。
testWhileIdle: 在检测空闲对象线程检测到对象不需要移除时，是否检测对象的有效性。true是，默认值是false。

timeBetweenEvictionRunsMillis：空闲对象检测线程的执行周期，即多长时候执行一次空闲对象检测。单位是毫秒数。如果小于等于0，则不执行检测线程。默认值是-1;

blockWhenExhausted: 当对象池没有空闲对象时，新的获取对象的请求是否阻塞。true阻塞。默认值是true;

maxTotal：对象池中管理的最多对象个数。默认值是8。

maxIdle：对象池中最大的空闲对象个数。默认值是8。

minIdle：对象池中最小的空闲对象个数。默认值是0。

怎么用

添加依赖

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

需要池化的对象,缓存的对象

public class Resource {

    private static int id;
    private int rid;
    
    public Resource() {
        synchronized (this) {
            this.rid = id++;
        }
    }
    
    public int getRid() {
        return this.rid;
    }
    
    @Override
    public String toString() {
        return "id:" + this.rid;
    }
    
}

创建工厂类

public class MyPoolableObjectFactory extends BasePooledObjectFactory<Resource>{
    
    /**
     * 创建一个对象实例
     */
    @Override
    public Resource create() throws Exception {
        return new Resource();
    }
    
    /**
     * 包裹创建的对象实例，返回一个pooledobject
     */
    @Override
    public PooledObject<Resource> wrap(Resource obj) {
        return new DefaultPooledObject<Resource>(obj);
    }
    
}

客户端调用

public class Test {

    public static void main(String[] args) {
        // 创建池对象工厂
        PooledObjectFactory<Resource> factory = new MyPoolableObjectFactory();
        
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        // 最大空闲数
        poolConfig.setMaxIdle(5);
        // 最小空闲数, 池中只有一个空闲对象的时候，池会在创建一个对象，并借出一个对象，从而保证池中最小空闲数为1
        poolConfig.setMinIdle(1);
        // 最大池对象总数
        poolConfig.setMaxTotal(20);
        // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
        poolConfig.setMinEvictableIdleTimeMillis(1800000);
        // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
        poolConfig.setTimeBetweenEvictionRunsMillis(1800000 * 2L);
        // 在获取对象的时候检查有效性, 默认false
        poolConfig.setTestOnBorrow(true);
        // 在归还对象的时候检查有效性, 默认false
        poolConfig.setTestOnReturn(false);
        // 在空闲时检查有效性, 默认false
        poolConfig.setTestWhileIdle(false);
        // 最大等待时间， 默认的值为-1，表示无限等待。
        poolConfig.setMaxWaitMillis(5000);
        // 是否启用后进先出, 默认true
        poolConfig.setLifo(true);
        // 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
        poolConfig.setBlockWhenExhausted(true);
        // 每次逐出检查时 逐出的最大数目 默认3
        poolConfig.setNumTestsPerEvictionRun(3);
        
        // 创建对象池
        final GenericObjectPool<Resource> pool = new GenericObjectPool<Resource>(factory, poolConfig);  
        
        for (int i = 0; i < 40; i++) {  
            new Thread(new Runnable() {  
                @Override  
                public void run() {  
                    try {  
                        Resource resource = pool.borrowObject();// 注意，如果对象池没有空余的对象，那么这里会block，可以设置block的超时时间  
                        System.out.println(resource);  
                        Thread.sleep(1000);  
                        pool.returnObject(resource);// 申请的资源用完了记得归还，不然其他人要申请时可能就没有资源用了  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                }  
            }).start();  
        }  
    }
    
}

例二:

创建对象

/**
 * FileName :Conn
 * Author :zengzhijun
 * Date : 2018/5/30 19:41
 * Description:
 */
package com.byedbl.pool.example1;


import org.slf4j.LoggerFactory;

/**
 * common-pool2 使用方式
 * <p/>
 * 假设这是一个建立TCP连接的对象，该对象的初始化时间平均为500ms，为了避免在程序中频繁创建Conn对象，我们需要借助对象池管理Conn对象实例
 *
 * @author : zengzhijun
 * @date : 2018/5/30 19:42
 **/
public class Conn {
    /**
     * 记录对象的创建时间
     */
    private long createTime;


    /**
     * 初始化Conn对象，模拟创建Conn对象平均消耗500ms
     * @throws InterruptedException
     */
    public Conn() throws InterruptedException {
        Thread.sleep(500);
        createTime = System.currentTimeMillis();
        LoggerFactory.getLogger(getClass()).debug(" init conn suc... " + createTime);
    }

    /**
     * 报告Conn对象信息
     */
    public void report() {
        LoggerFactory.getLogger(getClass()).info("this is a available conn " + createTime);
    }
}

创建对象的工厂

/**
 * FileName :ConnFactory
 * Author :zengzhijun
 * Date : 2018/5/30 19:46
 * Description:
 */
package com.byedbl.pool.example1;

import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;

/**
 * common-pool2 使用方式
 * <p/>
 * 为了使用common-pool2对象池管理，我们必须实现{@link org.apache.commons.pool2.PooledObjectFactory}或者其子类
 * 这是一个工厂模式，告诉对象池怎样去创建要管理的对象
 * <p/>
 * BasePooledObjectFactory 是对{@link org.apache.commons.pool2.PooledObjectFactory}的一个基本实现，我们可以继承该类，减少一些方法的实现
 * <p/>
 * 在实现{@link org.apache.commons.pool2.PooledObjectFactory}接口时，我们一定要实现的接口方法是{@link org.apache.commons.pool2.PooledObjectFactory#makeObject()}方法。
 *
 * @author : zengzhijun
 * @date : 2018/5/30 19:46
 **/
public class ConnFactory extends BasePooledObjectFactory<Conn> {


    /**
     * 间接实现{@link org.apache.commons.pool2.PooledObjectFactory#makeObject()}方法，表明怎样创建需要管理对象
     */
    @Override
    public Conn create() throws Exception {
        return new Conn();
    }


    /**
     * 在common-pool2中为了统计管理的对象的一些信息，比如调用次数，空闲时间，上次使用时间等，需要对管理的对象进行包装，然后在放入到对象池中
     *
     * @param obj 对象池要管理的对象
     * @return 返回包装后的PooledObject对象
     */
    @Override
    public PooledObject<Conn> wrap(Conn obj) {
        return new DefaultPooledObject<Conn>(obj);
    }
}

创建对象池

/**
 * FileName :ConnPool
 * Author :zengzhijun
 * Date : 2018/5/30 19:51
 * Description:
 */
package com.byedbl.pool.example1;

import org.apache.commons.pool2.impl.GenericObjectPool;

/**
 * common-pool2 使用方式
 * <p/>
 * Conn对象管理池，这里利用 GenericObjectPool 作为对象池
 *
 * @author : zengzhijun
 * @date : 2018/5/30 19:52
 **/
public class ConnPool extends GenericObjectPool<Conn> {


    /**
     * 调用{@link GenericObjectPool}的构造方法，构造ConnPool
     */
    public ConnPool() {
        super(new ConnFactory(), new ConnPoolConfig());
    }

    /**
     * 调用{@link GenericObjectPool}的构造方法，构造ConnPool
     */
    public ConnPool(ConnPoolConfig connPoolConfig) {
        super(new ConnFactory(), connPoolConfig);
    }
}

对象池配置

/**
 * FileName :ConnPoolConfig
 * Author :zengzhijun
 * Date : 2018/5/30 19:50
 * Description:
 */
package com.byedbl.pool.example1;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

/**
 * common-pool2 使用方式
 * <p/>
 * {@link org.apache.commons.pool2.impl.GenericObjectPool}支持个性化配置，我们可以配置对象池中总共的对象数，最大、最小空闲对象数等等
 * 这边继承{@link GenericObjectPoolConfig}是为了ConnPool也可以进行个性化的配置
 *
 * @author : zengzhijun
 * @date : 2018/5/30 19:50
 **/
public class ConnPoolConfig  extends GenericObjectPoolConfig {

    public ConnPoolConfig() {
        // defaults to make your life with connection pool easier :)
        setMinIdle(5);
        setTestOnBorrow(true);
    }
}

客户端用法

package com.byedbl.pool.example1;

import org.junit.Test;

public class ConnPoolTest {

    @Test
    public void conn() throws Exception {
        ConnPoolConfig connPoolConfig = new ConnPoolConfig();
        connPoolConfig.setMinIdle(5);
        connPoolConfig.setMaxIdle(8);
        ConnPool connPool = new ConnPool(connPoolConfig);
        Conn conn1 = connPool.borrowObject();
        Conn conn2 = connPool.borrowObject();
        Conn conn3 = connPool.borrowObject();
        Conn conn4 = connPool.borrowObject();
        Conn conn5 = connPool.borrowObject();
        conn1.report();
        connPool.returnObject(conn1);
        conn2.report();
        connPool.returnObject(conn2);
        conn3.report();
        connPool.returnObject(conn3);
        conn4.report();
        connPool.returnObject(conn4);
        conn5.report();
        connPool.returnObject(conn5);

        conn5.report();

        // 被归还的对象的引用，不可以在次归还
        // java.lang.IllegalStateException: Object has already been retured to this pool or is invalid
        try {
            connPool.returnObject(conn5);
        }catch (Exception e){
            e.printStackTrace();
        }
    }


}

common-pool2连接池详解与使用
 common-pool2 使用
 使用示例源码
 一个FTP的工具工程
 thrift-client-manager
apache-common-pool2源码分析
 commons-pool2源码分析

作者：巨子联盟
链接：https://www.jianshu.com/p/f403f1782d1c
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

转载于:https://my.oschina.net/u/2391658/blog/3081238