Pool.java

public interface Poolable<E> {
    E getNext();
    void setNext(E next);
    boolean isActive();
    E reset();
}

public enum PoolBehavior {
    EXPAND,
    DESTROY,
    NULL
}

// aka stack
public class PoolBuffer<E extends Poolable<E>> {
    private E top;

    public PoolBuffer() {
        top = null;
    }

    public E push(E e) {
        e.setNext(top);
        top = e;
        return top;
    }

    public E peek() {
        return top;
    }

    public E pop() {
        E tmp = top;
        top = top.getNext();
        return tmp;
    }
}

public class Pool<E extends Poolable<E>> {

    private final PoolBuffer<E> buffer;
    private final PoolBehavior behavior;
    private final Callable<E> factory;

    public Pool(int size, PoolBehavior behavior, Callable<E> factory) {
        if (size < 1) {
            throw new IllegalArgumentException("Invalid size " + size);
        }
        this.behavior = behavior;
        this.factory = factory;
        buffer = new PoolBuffer<>();

        E end = buffer.push(create());
        for (int i = 0; i < size - 1; i++) {
            buffer.push(create());
        }
        end.setNext(buffer.peek());
    }

    protected E create() {
        try {
            return factory.call();e
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public E acquire() {
        if (buffer.peek().isActive()) {
            switch (behavior) {
            case DESTROY:
                // Ignore that it's active and reset it anyway
                break;
            case EXPAND:
                release(create());
                break;
            case NULL:
                return null;
            }
        }
        return buffer.pop().reset();
    }

    public void release(E e) {
        if (e == null) {
            return;
        }
        assert !e.isActive();
        buffer.push(e);
    }
}