设计模式--对象池

来源：互联网发布：字符数组的定义编辑：程序博客网时间：2024/04/27 23:20

定义

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

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

实现

1. Reusable - 对象池中的对象，通常实例化代价比较高。

2. Client - 使用一个对象的实例。

3. ReusablePool - 管理对象的实例化，回收和销毁。

[java] view plaincopy
// ObjectPool Class  
public abstract class ObjectPool<T> {  
  private long expirationTime;  
  
  private Hashtable<T, Long> locked, unlocked;  
  
  public ObjectPool() {  
    expirationTime = 30000; // 30 seconds  
    locked = new Hashtable<T, Long>();  
    unlocked = new Hashtable<T, Long>();  
  }  
  
  protected abstract T create();  
  
  public abstract boolean validate(T o);  
  
  public abstract void expire(T o);  
  
  public synchronized T checkOut() {  
    long now = System.currentTimeMillis();  
    T t;  
    if (unlocked.size() > 0) {  
      Enumeration<T> e = unlocked.keys();  
      while (e.hasMoreElements()) {  
        t = e.nextElement();  
        if ((now - unlocked.get(t)) > expirationTime) {  
          // object has expired 对象过期  
          unlocked.remove(t);  
          expire(t);  
          t = null;  
        } else {  
          if (validate(t)) {  
            unlocked.remove(t);  
            locked.put(t, now);  
            return (t);  
          } else {  
            // object failed validation 对象不生效  
            unlocked.remove(t);  
            expire(t);  
            t = null;  
          }  
        }  
      }  
    }  
    // no objects available, create a new one  
    t = create();  
    locked.put(t, now);  
    return (t);  
  }  
  
  public synchronized void checkIn(T t) {  
    locked.remove(t);  
    unlocked.put(t, System.currentTimeMillis());  
  }  
}  
  
//The three remaining methods are abstract   
//and therefore must be implemented by the subclass  
  
public class JDBCConnectionPool extends ObjectPool<Connection> {  
  
  private String dsn, usr, pwd;  
  
  public JDBCConnectionPool(String driver, String dsn, String usr, String pwd) {  
    super();  
    try {  
      Class.forName(driver).newInstance();  
    } catch (Exception e) {  
      e.printStackTrace();  
    }  
    this.dsn = dsn;  
    this.usr = usr;  
    this.pwd = pwd;  
  }  
  
  @Override  
  protected Connection create() {  
    try {  
      return (DriverManager.getConnection(dsn, usr, pwd));  
    } catch (SQLException e) {  
      e.printStackTrace();  
      return (null);  
    }  
  }  
  
  @Override  
  public void expire(Connection o) {  
    try {  
      ((Connection) o).close();  
    } catch (SQLException e) {  
      e.printStackTrace();  
    }  
  }  
  
  @Override  
  public boolean validate(Connection o) {  
    try {  
      return (!((Connection) o).isClosed());  
    } catch (SQLException e) {  
      e.printStackTrace();  
      return (false);  
    }  
  }  
}  
  
public class Main {  
  public static void main(String args[]) {  
    // Do something...  
    ...  
  
    // Create the ConnectionPool:  
    JDBCConnectionPool pool = new JDBCConnectionPool(  
      "org.hsqldb.jdbcDriver", "jdbc:hsqldb://localhost/mydb",  
      "sa", "secret");  
  
    // Get a connection:  
    Connection con = pool.checkOut();  
  
    // Use the connection  
    ...  
  
    // Return the connection:  
    pool.checkIn(con);  
   
  }  
}  