利用Apache Common将java对象池化的问题

什么是对象池化？

对象被创建后，使用完毕不是立即销毁回收对象，而是将对象放到一个容器保存起来，下次使用的时候不用创建对象，而是从容器中直接获取。


什么样的对象需要池化?

一般需要池化的对象往往都是比”重量级”较的对象，创建和销毁都比较耗时，比如我们的”线程”,”数据库链接对象”，”tcp链接对象”, “FTP链接对象” 等等。


对象池化的好处?

这些对象池化后，之后使用的时候不用创建,直接使用即可，可以大大缩短程序的运行时间，以及创建对象时对CPU资源的消耗，以及对系统资源的控制(池化的对象数量有限，不会一直创建对象，导致系统资源耗尽，或者造成程序OOM的情况)进而提高系统的稳定性。


对象池化后需要注意什么？

这些被池化的对象都有一个特点，都是”活的”，比如数据库链接对象内部一般保存了一个TCP链接，所以，这个对象”能用”的前提是这个TCP链接是有效的，线程对象”能用”的前提是线程的状态不是”凋亡”状态，所以我们有必要定期对对象的”健康状态”进行检查，剔除掉”不能用”的对象，并填充新的对象给”对象池”。


使用apache-common-pool池化对象

引入依赖

1.         <dependency>
2.             <groupId>org.apache.commons</groupId>
3.             <artifactId>commons-pool2</artifactId>
4.             <version>2.9.0</version>
5.         </dependency>

复制代码

需要池化的对象示例

1. public class Foo {
2.     private final String username;
3.     public Foo(String username) {
4.         this.username = username;
5.     }
6.     public String getUsername() {
7.         return username;
8.     }
9. }

复制代码

构建对象创建工厂

可以直接实现org.apache.commons.pool2.PooledObjectFactory<T>接口实现创建、销毁、钝化、取消等接口，也可以使用他的抽象类，实现创建和包装方法即可。

1. public class FooPoolObjectFactory extends BasePooledObjectFactory<Foo> {
2.     @Override
3.     public Foo create() throws Exception {
4.         return new Foo(String.valueOf(RandomUtils.randomInt(0, 10)));
5.     }
6.     @Override
7.     public PooledObject<Foo> wrap(Foo obj) {
8.         return new DefaultPooledObject<>(obj);
9.     }
10. }

复制代码

实现驱逐策略

一般数据库链接对象，要定期进行心跳，确保链接可用，如果链接断开，需要销毁对象，并重新创建新的对象。common-pool中，我们可以实现驱逐策略，对对象进行定期检查

1. public class FooEvictionPolicy implements EvictionPolicy<Foo> {
2.     @Override
3.     public boolean evict(EvictionConfig config, PooledObject<Foo> underTest, int idleCount) {
4.         // todo  定期检查对象某些功能是否可用
5.         return true;
6.     }
7. }

复制代码

构建&配置对象池

1.     public GenericObjectPool<Foo> fooGenericObjectPool() {
2.         GenericObjectPoolConfig<Foo> poolConfig = new GenericObjectPoolConfig<>();
3.         poolConfig.setEvictionPolicy(new FooEvictionPolicy());
4.         poolConfig.setBlockWhenExhausted(true);
5.         poolConfig.setJmxEnabled(false);
6.         poolConfig.setMaxWaitMillis(1000 * 10);
7.         poolConfig.setTimeBetweenEvictionRunsMillis(60 * 1000);
8.         poolConfig.setMinEvictableIdleTimeMillis(20 * 1000);
9.         poolConfig.setTestWhileIdle(true);
10.         poolConfig.setTestOnReturn(true);
11.         poolConfig.setTestOnBorrow(true);
12.         poolConfig.setMaxTotal(3);
13.         // 设置抛弃策略
14.         AbandonedConfig abandonedConfig = new AbandonedConfig();
15.         abandonedConfig.setRemoveAbandonedOnMaintenance(true);
16.         abandonedConfig.setRemoveAbandonedOnBorrow(true);
17.         return new GenericObjectPool<>(new FooPoolObjectFactory(), poolConfig, abandonedConfig);
18.     }

复制代码 如果我们使用的是spring容器，一般我们需要将该对象交由spring管理。

获取&归还对象

1.     private final GenericObjectPool<Foo> fooGenericObjectPool = fooGenericObjectPool();
2.     public Foo borrowFoo () throws Exception {
3.         return fooGenericObjectPool.borrowObject();
4.     }
5.     public void returnObject(Foo foo){
6.         fooGenericObjectPool.returnObject(foo);
7.     }

复制代码 到此这篇关于利用Apache Common将java对象“池化”的文章就介绍到这了,更多相关Apache Common java对象池化内容请搜索软件技术网以前的文章或继续浏览下面的相关文章希望大家以后多多支持软件技术网！