java对象池(导包、使用)

对象复用-“池”

对象池相关：

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

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

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

下面以线程池为例介绍用法：
1、从导包开始

首先在Apache下载commons-pool2.rar包

下载地址

以下为导入过程

已经导入成功。

下面创建一个简单的对象池工厂：

package ObjectPool;

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

import javax.print.attribute.standard.JobKOctets;
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;
              }
          }
  
      } }
  

输出结果：

• 0 create Object 0
  0
  0 create Object 1 create Object 2 Before borrow Object: 2, State: ALLOCATED 2is get return Object: 2, State: RETURNING
  1 Before borrow Object: 2, State: ALLOCATED 2is get return Object: 2, State: RETURNING
  2 Before borrow Object: 2, State: ALLOCATED //此处省略 return Object: 1, State: RETURNING Destroy Object Object: 1, State:
  INVALID Destroy Object Object: 2, State: INVALID Destroy Object
  Object: 0, State: INVALID

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