Java 程序优化之对象池

1、对象池概念

如果一个类被频繁请求使用,那么不必每次都生成一个实例,可以将这个类都一些实例保存到一个“池”中,待需要使用的时候直接从“池”中获取。这个“池”就被称为对象池,它可以是一个数组,一个链表或者任何集合。

对象池其实就是一个集合,里面包含了我们需要的对象集合,当然这些对象都被池化了,也就是被对象池所管理,想要这样的对象,从池子里取个就行,但是用完得归还。对象池的对象最好是创建比较费时的大对象,如果是太简单的对象,再进入池化的时间比自己构建还多,就不划算了。可以理解对象池为单例模式的延展,多例模式,就那么几个对象实例,再多没有了。

在程序中使用数据库连接池和线程池,可以有效的改善系统在高并发下的性能,这是两个非常重要的性能组件,任何对性能敏感的系统,都需要考虑合理配置这两个组件。

2、线程池使用流程

  • 在Apache官网下载commons-pool2.rar包

下载地址:commons.apache.org/proper/com

  • 导入过程
  • 下面创建一个简单的对象池工厂
package ObjectPool;

import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import java.util.concurrent.atomic.AtomicInteger;

public class PoolableObjectFactoryDome<T> implements PooledObjectFactory<Object> {
    private static AtomicInteger counter = new AtomicInteger(0);


    @Override
    public PooledObject<Object> makeObject() throws Exception {
        Object obj = String.valueOf(counter.getAndIncrement());
        System.out.println("create Object " + obj);
        PooledObject<Object> pooledObject = new DefaultPooledObject<>(obj);
        return  pooledObject;
    }


    @Override
    public void destroyObject(PooledObject<Object> pooledObject) throws Exception {
        System.out.println("Destroy Object " + pooledObject);
    }

    @Override
    public boolean validateObject(PooledObject<Object> pooledObject) {
        return false;
    }

    @Override
    public void activateObject(PooledObject<Object> pooledObject) throws Exception {
        System.out.println("Before borrow " + pooledObject);
    }

    @Override
    public void passivateObject(PooledObject<Object> pooledObject) throws Exception {
        System.out.println("return " + pooledObject);
    }


}

对象池使用例子如下:

package ObjectPool;

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

import java.util.concurrent.atomic.AtomicInteger;

public class ObjectPoolDemo {
    static PooledObjectFactory<Object> factory = new PoolableObjectFactoryDome();
    static ObjectPool pool = new GenericObjectPool(factory);

    private static AtomicInteger endcount = new AtomicInteger(0);
    public static class PoolThread extends Thread{
        public void run(){
            Object obj = null;
            try{
                for (int i = 0; i < 100; i++){
                    System.out.println("==" + i + "==");
                    obj = pool.borrowObject();
                    System.out.println(obj + "is get");
                    pool.returnObject(obj);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                //以原子性操作自增一
                endcount.getAndIncrement();
            }
        }
    }

    public static void main(String[] args) {
        new PoolThread().start();
        new PoolThread().start();
        new PoolThread().start();

        while (true){
            if (endcount.get() == 3){//等待三个线程全部结束
                pool.close();
                break;
            }
        }

    }
}

输出结果:

3、总结

在3个线程向对象池获取对象的过程中,一共建立三个对象,这三个对象不停的复用,当对象池被关闭时,使用的对象池工厂的destoryObject()方法,销毁对象,释放资源。

原文发布于微信公众号 - JavaArtisan(gh_f521f5243781)

原文发表时间:2019-05-29

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券