ObjectPool.java

public class ObjectPool<T> {

    private final Object poolSync = new Object();

    private SparseArray<T> freePool;
    private SparseArray<T> lentPool;
    private PooledObjectCreator<T> objectCreator;

    public ObjectPool(int initialCapacity, PooledObjectCreator<T> objectCreator) {
        this.objectCreator = objectCreator;
        initialize(initialCapacity);
    }

    @NonNull
    public final T acquire() {
        T t;
        synchronized (poolSync) {
            int freeSize = freePool.size();
            for (int i = 0; i < freeSize; i++) {
                int key = freePool.keyAt(i);
                t = freePool.get(key);
                if (t != null) {
                    this.lentPool.put(key, t);
                    this.freePool.remove(key);
                    return t;
                }
            }
            t = objectCreator.create();
            lentPool.put(lentPool.size() + freeSize, t);
        }
        return t;
    }

    public final void release(@Nullable T t) {
        if (t == null) {
            return;
        }
        synchronized (poolSync) {
            int key = lentPool.indexOfValue(t);
            objectCreator.restore(t);
            this.freePool.put(key, t);
            this.lentPool.remove(key);
        }
    }

    private void initialize(final int initialCapacity) {
        lentPool = new SparseArray<>(initialCapacity);
        freePool = new SparseArray<>(initialCapacity);
        for (int i = 0; i < initialCapacity; i++) {
            freePool.put(i, objectCreator.create());
        }
    }

    public interface PooledObjectCreator<T> {

        @NonNull
        T create();

        void restore(@NonNull T object);
    }
}