举例讲解Java设计模式中的对象池模式编程

前端技术 2023/09/03 Java

定义
一个对象池是一组已经初始化过且可以使用的对象的集合，池的用户可以从池子中取得对象，对其进行操作处理，并在不需要时归还给池子而非销毁它。

若初始化、实例化的代价高，且有需求需要经常实例化，但每次实例化的数量较少的情况下，使用对象池可以获得显著的效能提升。从池子中取得对象的时间是可预测的，但新建一个实例所需的时间是不确定。

实现

1. Reusable - 对象池中的对象，通常实例化代价比较高。
2. Client - 使用一个对象的实例。
3. ReusablePool - 管理对象的实例化，回收和销毁。

单个实例中主要的思想
1.一个栈，这里用stack
2.初始化方法，容器开启的时候可以预先创建池
3.创建实例的方法
4.提供从池中获得对象实例的方法
5.提供返回的方法,不返回后果很严重
6.控制请求等待时间的方法，过了一定的事件还没获得对象实例，就返回一个null指针

import java.util.Stack; 
 
@SuppressWarnings(\"unchecked\") 
public class ObjectPool { 
 
  public ObjectPool() { 
  } 
 
  private PoolParam poolParam; 
 
  public void setPoolParam(PoolParam poolParam) { 
    this.poolParam = poolParam; 
  } 
 
  // 当前总对象个数 
  private int currentNum = 0; 
 
  private Class clazz; 
 
  public void setClazz(Class clazz) { 
    this.clazz = clazz; 
  } 
 
  // 栈，用来存放对象，模拟一个池 
  private Stack stack; 
 
  public Stack getStack() { 
    return stack; 
  } 
 
  public void setStack(Stack stack) { 
    this.stack = stack; 
  } 
 
  // ................................................................. 
  // 等待超时的记数变量 
  private int timeWait = 0; 
 
  // ................................................................. 
 
  // 创建对象池 
  public void initalPool(PoolParam poolParam, Class clazz) { 
 
    this.setPoolParam(poolParam); 
    this.setClazz(clazz); 
 
    stack = new Stack(); 
 
    stack.clear(); 
 
    // System.out.println(\"obj..pool is initial...\"); 
    // 生成配置最小对象数，并压入栈中 
    try { 
 
      for (int i = 0; i < poolParam.getMinObjectCount(); i++) { 
 
        // 根据poolParam初始化对象池 
        stack.push(clazz.newInstance()); 
      } 
 
    } catch (InstantiationException e) { 
      e.printStackTrace(); 
    } catch (IllegalAccessException e) { 
      e.printStackTrace(); 
    } 
 
  } 
 
  // 创建单个对象 
  private Object createObj(Class clazz) { 
 
    Object obj = null; 
    try { 
 
      obj = clazz.newInstance(); 
 
      // System.out.println(\"a new one...\"); 
    } catch (InstantiationException e) { 
      e.printStackTrace(); 
    } catch (IllegalAccessException e) { 
      e.printStackTrace(); 
    } 
 
    return obj; 
  } 
 
  // 对象池提供的get方法 
  public Object getInstance(){ 
 
    // System.out.println(stack.size()); 
 
    Object object = null; 
 
    if (stack.size() == 0) { 
 
      // 如果当前栈的长度为0，并且总的对象数没有超过定义最大数 
      if ((currentNum + poolParam.getMinObjectCount()) < poolParam 
          .getMaxObjectCount()) { 
 
        // 新创建一个对象 
        object = this.createObj(clazz); 
        // 对象数+1 
        currentNum++; 
 
      } else { 
 
        synchronized (this) { 
 
          try { 
            waitme(this); 
          } catch (Exception e) { 
            e.printStackTrace(); 
          } 
 
          // 获得通知后检测栈中是为空，并给出刚刚释放的资源 
          if (!stack.empty()) { 
            object = stack.pop(); 
          } 
        } 
      } 
 
    } else if (stack.size() > 0) { 
 
      object = stack.pop(); 
 
      // System.out.println(stack.size()); 
    } 
 
    return object; 
  } 
 
  // 返回对象的方法 
  public void returnObj(Object obj) { 
 
    if (clazz.isInstance(obj)) { 
 
      stack.push(obj); 
 
      synchronized (this) { 
 
        notify(); 
      } 
    } else { 
      System.out.println(\"this object can not push to stack!\"); 
    } 
 
  } 
 
  // 等待递归算法 
  private void waitme(ObjectPool pool) { 
 
    // 等待2s的技术控制 
    if (timeWait >= 2000) { 
      System.out.println(\"jump up this step..\"); 
 
      timeWait = 0; 
      return; 
 
    } else { 
 
      try { 
 
        pool.wait(500); 
 
        // 等待计数累加。。 
        timeWait +=1000; 
 
        System.out.println(\"waiting time to free obj..\"); 
 
        if (stack.empty()) { 
          System.out.println(\"agian....\"); 
          waitme(pool); 
        } 
 
      } catch (InterruptedException e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
 
}

 
管理池类，这个不是很难，同步了就好

@SuppressWarnings(\"unchecked\") 
public class ObjectPoolManage { 
 
  private ObjectPoolManage() { 
  } 
 
  private static ObjectPool pool; 
   
 
 
  // 实现一个单例的获取方法....默认 
  public static synchronized ObjectPool getCacheObject(Class clazz) { 
 
    if (null != pool) { 
      return pool; 
    } else { 
 
      createObjectPool(null, clazz); 
      return pool; 
    } 
 
  } 
 
  // 实现一个单例的获取方法...自定义 
 
  public static synchronized ObjectPool getCacheObject(PoolParam p, Class clazz) { 
    if (null != pool) { 
      return pool; 
    } else { 
 
      createObjectPool(p, clazz); 
      return pool; 
    } 
 
  } 
 
  private static ObjectPool createObjectPool(PoolParam p, Class clazz) { 
 
    pool = new ObjectPool(); 
 
    if (null == p) { 
      pool.initalPool(new PoolParam(5,10), clazz); 
    } else { 
      pool.initalPool(p, clazz); 
    } 
 
    return pool; 
  } 
   
  private static Class getclazz(){ 
     
    Class clazz=null; 
     
    try { 
      clazz= Class.forName(ppp.getPropertyByName(\"objectPath\")); 
    } catch (ClassNotFoundException e) { 
      e.printStackTrace(); 
    } 
     
    return clazz; 
  } 
}


相关问题和实现
1. 对象池中可以限制对象的个数，当超过限制时，对象池需要返回异常或者空值，以通知客户。
2. 在多线程环境中，在checkout和checkin方法需要同步。
3. 定时清理过期的对象。

本文地址：https://www.stayed.cn/item/8167

转载请注明出处。

本站部分内容来源于网络,如侵犯到您的权益,请 联系我

我的博客

人生若只如初见，何事秋风悲画扇。

我的标签

随笔档案