对象池设计模式

对象池模式是一种软件创建设计模式，用于初始化类实例的成本非常高的情况。

基本上，对象池是一个包含一定数量对象的容器。所以，当一个对象从池中取出时，它在池中不可用，直到它被放回。
池中的对象有一个生命周期：

• 创建
• 验证
• 破坏。

UML 图对象池设计模式

• Client ：这是使用 PooledObject 类型的对象的类。
• ReuseablePool ： PooledObject 类是实例化成本高、速度慢或可用性有限的类型，因此将保留在对象池中。
• ObjectPool ： Pool 类是对象池设计模式中最重要的类。 ObjectPool 维护可用对象列表和已从池中请求的对象集合。

让我们以数据库连接为例。显然，由于以下几个原因，打开过多的连接可能会影响性能：

• 创建连接是一项昂贵的操作。
• 当打开的连接过多时，创建新连接需要更长的时间，并且数据库服务器将变得过载。

在这里，对象池管理连接并提供一种重用和共享它们的方法。它还可以限制可以创建的最大对象数。

Java

// Java program to illustrate
// Object Pool Design Pattern
abstract class ObjectPool {
    long deadTime;
 
    Hashtable lock, unlock;
 
    ObjectPool()
    {
        deadTime = 50000; // 50 seconds
        lock = new Hashtable();
        unlock = new Hashtable();
    }
 
    abstract T create();
 
    abstract boolean validate(T o);
 
    abstract void dead(T o);
 
    synchronized T takeOut()
    {
        long now = System.currentTimeMillis();
        T t;
        if (unlock.size() > 0) {
            Enumeration e = unlock.keys();
            while (e.hasMoreElements()) {
                t = e.nextElement();
                if ((now - unlock.get(t)) > deadTime) {
                    // object has deadd
                    unlock.remove(t);
                    dead(t);
                    t = null;
                }
                else {
                    if (validate(t)) {
                        unlock.remove(t);
                        lock.put(t, now);
                        return (t);
                    }
                    else {
                        // object failed validation
                        unlock.remove(t);
                        dead(t);
                        t = null;
                    }
                }
            }
        }
        // no objects available, create a new one
        t = create();
        lock.put(t, now);
        return (t);
    }
    synchronized void takeIn(T t)
    {
        lock.remove(t);
        unlock.put(t, System.currentTimeMillis());
    }
}
 
// Three methods are abstract
// and therefore must be implemented by the subclass
 
class JDBCConnectionPool extends ObjectPool {
    String dsn, usr, pwd;
 
    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;
    }
 
    Connection create()
    {
        try {
            return (DriverManager.getConnection(dsn, usr, pwd));
        }
        catch (SQLException e) {
            e.printStackTrace();
            return (null);
        }
    }
 
    void dead(Connection o)
    {
        try {
            ((Connection)o).close();
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
    }
 
    boolean validate(Connection o)
    {
        try {
            return (!((Connection)o).isClosed());
        }
        catch (SQLException e) {
            e.printStackTrace();
            return (false);
        }
    }
}
 
class Main {
    public static void main(String args[])
    {
        // Create the ConnectionPool:
        JDBCConnectionPool pool = new JDBCConnectionPool(
            "org.hsqldb.jdbcDriver", "jdbc:hsqldb: //localhost/mydb",
            "sa", "password");
 
        // Get a connection:
        Connection con = pool.takeOut();
        // Return the connection:
        pool.takeIn(con);
    }
}

好处

• 它提供了显着的性能提升。
• 它管理连接并提供一种重用和共享它们的方法。
• 当初始化类的实例的速度很高时，使用对象池模式。

何时使用对象池设计模式

• 当我们需要分配或释放许多对象时
• 此外，当我们知道同时在内存中的对象数量有限时。

参考 ：
https://sourcemaking.com/design_patterns/object_pool