在Java创建多个可变大小对象池

在Java中，对象池是一种常见的设计模式，它可以有效地管理对象的创建和销毁，提高系统的性能。对象池通过预先创建一定数量的对象，将这些对象存放在一个池中，当需要使用这些对象时，直接从池中取出即可。这种方式可以减少对象的创建和垃圾回收，提高系统的吞吐量。

1. 使用Apache Commons Pool

Apache Commons Pool是一个常用的对象池实现库，它提供了通用的对象池和可定制的对象池接口，支持多线程和高并发环境。使用Apache Commons Pool创建对象池主要包括以下几个步骤：

（1）定义对象工厂

对象工厂负责创建和销毁池中的对象，需要实现PoolableObjectFactory接口。例如：

public class MyObjectFactory implements PoolableObjectFactory<MyObject> {
    @Override
    public MyObject makeObject() throws Exception {
        return new MyObject();
    }

    @Override
    public void destroyObject(MyObject obj) throws Exception {
        obj.close();
    }

    @Override
    public boolean validateObject(MyObject obj) {
        return true;
    }

    @Override
    public void activateObject(MyObject obj) throws Exception {
        obj.activate();
    }

    @Override
    public void passivateObject(MyObject obj) throws Exception {
        obj.passivate();
    }
}

（2）创建对象池

创建对象池需要使用GenericObjectPool类，可以设置池中对象的最大数量、最小数量、池中对象的空闲时间等参数。例如：

GenericObjectPool<MyObject> objectPool = new GenericObjectPool<>(new MyObjectFactory());
objectPool.setMaxTotal(100); // 设置池中对象的最大数量
objectPool.setMaxIdle(10); // 设置池中对象的最大空闲数量
objectPool.setMinIdle(5); // 设置池中对象的最小空闲数量
objectPool.setMaxWaitMillis(5000); // 设置从池中获取对象的等待时间

（3）使用对象池

使用对象池需要调用borrowObject()方法获取池中的对象，用完后调用returnObject()方法将对象返回池中。例如：

MyObject obj = objectPool.borrowObject();
try {
    // 使用对象...
} finally {
    objectPool.returnObject(obj);
}

2. 自定义对象池

除了使用现成的对象池实现库，我们也可以自己实现一个对象池。下面是一个简单的自定义对象池实现：

public class MyObjectPool<T> {
    private final ObjectFactory<T> objectFactory;
    private final List<T> objectPool;
    private int maxTotal;
    private int maxIdle;
    private long maxWaitMillis;

    public MyObjectPool(ObjectFactory<T> objectFactory) {
        this.objectFactory = objectFactory;
        this.objectPool = new ArrayList<>();
    }

    public void setMaxTotal(int maxTotal) {
        this.maxTotal = maxTotal;
    }

    public void setMaxIdle(int maxIdle) {
        this.maxIdle = maxIdle;
    }

    public void setMaxWaitMillis(long maxWaitMillis) {
        this.maxWaitMillis = maxWaitMillis;
    }

    public synchronized T borrowObject() throws Exception {
        long startMillis = System.currentTimeMillis();
        while (objectPool.isEmpty()) {
            if (System.currentTimeMillis() - startMillis > maxWaitMillis) {
                throw new Exception("Timeout waiting for idle objects");
            }
            wait(maxWaitMillis);
        }
        T obj = objectPool.remove(objectPool.size() - 1);
        return obj;
    }

    public synchronized void returnObject(T obj) {
        if (objectPool.size() < maxIdle) {
            objectPool.add(obj);
        } else {
            objectFactory.destroyObject(obj);
        }
        notifyAll();
    }
}

public interface ObjectFactory<T> {
    T createObject();
    void destroyObject(T obj);
}

使用自定义对象池的示例如下：

MyObjectPool<String> objectPool = new MyObjectPool<>(new ObjectFactory<String>() {
    public String createObject() {
        return new String();
    }
    public void destroyObject(String obj) {
        obj = null;
    }
});
objectPool.setMaxTotal(100); // 设置池中对象的最大数量
objectPool.setMaxIdle(10); // 设置池中对象的最大空闲数量
objectPool.setMaxWaitMillis(5000); // 设置从池中获取对象的等待时间

String str = objectPool.borrowObject();
try {
    // 使用对象...
} finally {
    objectPool.returnObject(str);
}

3. 总结

对象池是一种常见的设计模式，它可以有效地管理对象的创建和销毁，提高系统的性能。在Java中创建对象池可以使用现有的对象池实现库，也可以自己实现一个简单的对象池。关键是要了解对象池的基本原理和实现方式，合理设置池中对象的数量和空闲时间，以便更好地发挥对象池的性能优势。