Apache Pool 2 - 具有固定容量的预定义对象实例

Question

我想使用 Apache Pool 2 库，但正在寻找以下功能：

1. 对象不是虚拟的新空实例，而是来自外部数据源的预加载对象。您可以想象每个对象都是唯一的工作配置，可以传递给通用任务并且这样的任务将起作用。我不需要清理对象，只需将它们归还即可。
2. 池中的对象数量是固定的。

写我自己的池不是更好，还是有办法用 apache 来实现？

或者有没有更好的模式可以使用？

谢谢。

最好的问候，

拉迪斯拉夫

Answer 1

好的，我按照 Apache Pool 网站上的示例进行操作，还研究了文档，但是我真的没有找到如何将我之前创建的对象推入池中的方法，所以我找到工作的唯一方法虽然真的丑陋的是： 1. 一次循环从池中获取虚拟空对象并将它们放入外部ArrayList 2.遍历List并设置对象并将其返回到池中

在我尝试通过以下实现从池中获取对象后，那些保持其设置的行为符合预期，但我宁愿使用工厂来创建 PooledObject，我可以以某种方式将其推送到池中。我尝试了池对象的 use() 或 genericobjectfactory 的 wrap() 方法，但它没有像我预期的那样工作。因此，以下代码按预期工作，抱歉，我刚刚测试了功能，这很丑：

public class ProxyMetadata  {

    public static Logger LOG = LogManager.getLogger(ProxyMetadata.class);
    public static List<Proxy> PROXIES = new ArrayList<>();
    public static int PROXIES_AVAILABLE;

    private static ProxyBufferFactory proxyBufferFactory = new ProxyBufferFactory();
    private static GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
    private static GenericObjectPool<Proxy> pool;
    //Pool<Proxy> pool = new BoundedBlockingPool< Proxy >();


    void init() {
        final List<Proxy> availableProxies = getAvailableProxies();
        genericObjectPoolConfig.setMaxTotal(PROXIES_AVAILABLE);
        genericObjectPoolConfig.setBlockWhenExhausted(true);
        genericObjectPoolConfig.setTestOnBorrow(true);
        //pool = new BoundedBlockingPool< Proxy >();
        pool = new GenericObjectPool<Proxy>(proxyBufferFactory,genericObjectPoolConfig);
        List<Proxy> initializator = new ArrayList<>();
        LOG.debug("Pool management starting...");
        LOG.debug("Pool start idle:" + pool.getNumIdle());
        LOG.debug("Pool start active:" + pool.getNumActive());
        for (int i= 0; i < PROXIES_AVAILABLE; i++){
            try {

                //final Proxy proxy = new Proxy();
                final Proxy proxy = pool.borrowObject();
                proxy.setProxyHost(String.valueOf(i));
                //proxyBufferFactory.wrap(proxy);
                initializator.add(proxy);
                //pool.returnObject(proxy);
                LOG.debug("Pool idle - loop " + String.valueOf(i)+ ": " + pool.getNumIdle());
                LOG.debug("Pool active - loop"+ String.valueOf(i) + ": " + pool.getNumActive());

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        LOG.debug("ALL PROXIES BORROWED");
        LOG.debug("Pool after borrow idle:" + pool.getNumIdle());
        LOG.debug("Pool after borrow active:" + pool.getNumActive());
        LOG.debug("Going to return");
        for (Proxy proxy : initializator){
            pool.returnObject(proxy);
            LOG.debug("Pool after return idle:" + pool.getNumIdle());
            LOG.debug("Pool after return active:" + pool.getNumActive());
        }

        LOG.debug("Clearing buffer: " + initializator.size());
        initializator.clear();
        LOG.debug("Clearing buffer: " + initializator.size());
        LOG.debug("Pool status before reborrow.");
        LOG.debug("Pool idle:" + pool.getNumIdle());
        LOG.debug("Pool active:" + pool.getNumActive());
        for (int i= 0; i < PROXIES_AVAILABLE; i++){
            try {

                final Proxy proxy = pool.borrowObject();

                LOG.debug("Pool idle:" + pool.getNumIdle());
                LOG.debug("Pool active:" + pool.getNumActive());
                LOG.debug("Borrowed final proxy:" + proxy.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

这里是日志输出，可以看到最初借用和配置的借用对象再次可用：

Pool management starting...
Pool start idle:0
Pool start active:0
Pool idle - loop 0: 0
Pool active - loop0: 1
Pool idle - loop 1: 0
Pool active - loop1: 2
Pool idle - loop 2: 0
Pool active - loop2: 3
ALL PROXIES BORROWED
Pool after borrow idle:0
Pool after borrow active:3
Going to return
Pool after return idle:1
Pool after return active:2
Pool after return idle:2
Pool after return active:1
Pool after return idle:3
Pool after return active:0
Clearing buffer: 3
Clearing buffer: 0
Pool status before reborrow.
Pool idle:3
Pool active:0
Pool idle:2
Pool active:1
Borrowed final proxy:Proxy(proxyHost=2, proxyPort=null, proxyUser=null, proxyPassword=null, geoIPLocation=null, isAvailable=true)
Pool idle:1
Pool active:2
Borrowed final proxy:Proxy(proxyHost=1, proxyPort=null, proxyUser=null, proxyPassword=null, geoIPLocation=null, isAvailable=true)
Pool idle:0
Pool active:3
Borrowed final proxy:Proxy(proxyHost=0, proxyPort=null, proxyUser=null, proxyPassword=null, geoIPLocation=null, isAvailable=true)

    Process finished with exit code 0

所以行为符合预期，但我会简单地使用 PooledObject 的 put() 方法作为参数扩展池，因此您可以以更直观的方式初始化池...