关于如何使用Java ObjectPool/pools，有什么很好的教程或示例吗？

Question

我正在尝试创建一个到队列服务器的通道/连接池，并试图使用ObjectPool，但在他们网站上的example上使用它时遇到了问题。

到目前为止，我已经有了可以工作的线程，但我希望每个线程都从池中获取一个通道，然后将其返回。我知道如何使用它(borrowObject/returnObjects)，但不确定如何创建初始池。

下面是如何在rabbitmq中创建频道：

ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

而我的代码只是使用channel来做一些事情。我很困惑，因为我能找到的唯一示例(在他们的网站上)是这样开始的：

private ObjectPool<StringBuffer> pool;

    public ReaderUtil(ObjectPool<StringBuffer> pool) { 
        this.pool = pool;
    }

这对我来说没什么意义。我意识到这对于建立数据库连接很常见，所以我尝试使用数据库和ObjectPool查找教程，但它们似乎使用特定于数据库的DBCP (并且我似乎不能将逻辑用于我的队列服务器)。

关于如何使用它有什么建议吗？或者在java中还有另一种用于池的方法？

Answer 1

它们创建一个类来创建对象&知道在返回对象时要做什么。这对你来说可能是这样的：

public class PoolConnectionFactory extends BasePoolableObjectFactory<Connection> { 

    private final ConnectionFactory factory;
    public PoolConnectionFactory() {
        factory = new ConnectionFactory();
        factory.setHost("localhost");
    }

    // for makeObject we'll simply return a new Connection
    public Connection makeObject() { 
        return factory.newConnection();
    } 

    // when an object is returned to the pool,  
    // we'll clear it out 
    public void passivateObject(Connection con) { 
        con.I_don't_know_what_to_do(); 
    } 

    // for all other methods, the no-op  
    // implementation in BasePoolableObjectFactory 
    // will suffice 
}

现在，您可以在某个位置创建ObjectPool<Connection>：

ObjectPool<Connection> pool = new StackObjectPool<Connection>(new PoolConnectionFactory());

然后，您可以在线程中使用pool，如下所示

Connection c = pool.borrowObject();
c.doSomethingWithMe();
pool.returnObject(c);

对您来说没有意义的代码行是将池对象传递给不同类的一种方式。看最后一行，他们在创建阅读器的同时创建了池。

new ReaderUtil(new StackObjectPool<StringBuffer>(new StringBufferFactory()))

Answer 2

您将需要一个自定义的PoolableObjectFactory实现来创建、验证和销毁您想要池化的对象。然后，将工厂的一个实例传递给ObjectPool的构造器，就可以开始借用对象了。

下面是一些示例代码。您还可以查看commons-dbcp的源代码，它使用commons-pool。

import org.apache.commons.pool.BasePoolableObjectFactory;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.PoolableObjectFactory;
import org.apache.commons.pool.impl.GenericObjectPool;

public class PoolExample {
    public static class MyPooledObject {
        public MyPooledObject() {
            System.out.println("hello world");
        }

        public void sing() {
            System.out.println("mary had a little lamb");
        }

        public void destroy() {
            System.out.println("goodbye cruel world");
        }
    }

    public static class MyPoolableObjectFactory extends BasePoolableObjectFactory<MyPooledObject> {
        @Override
        public MyPooledObject makeObject() throws Exception {
            return new MyPooledObject();
        }

        @Override
        public void destroyObject(MyPooledObject obj) throws Exception {
            obj.destroy();
        }
        // PoolableObjectFactory has other methods you can override
        // to valdiate, activate, and passivate objects.
    }

    public static void main(String[] args) throws Exception {
        PoolableObjectFactory<MyPooledObject> factory = new MyPoolableObjectFactory();
        ObjectPool<MyPooledObject> pool = new GenericObjectPool<MyPooledObject>(factory);

        // Other ObjectPool implementations with special behaviors are available;
        // see the JavaDoc for details

        try {
            for (int i = 0; i < 2; i++) {
                MyPooledObject obj;

                try {
                    obj = pool.borrowObject();
                } catch (Exception e) {
                    // failed to borrow object; you get to decide how to handle this
                    throw e;
                }

                try {
                    // use the pooled object
                    obj.sing();

                } catch (Exception e) {
                    // this object has failed us -- never use it again!
                    pool.invalidateObject(obj);
                    obj = null; // don't return it to the pool

                    // now handle the exception however you want

                } finally {
                    if (obj != null) {
                        pool.returnObject(obj);
                    }
                }
            }
        } finally {
            pool.close();
        }
    }
}