Java Object Pool

ObjectPool.java

package pl.athlan.commons.pool;


import static java.util.stream.Collectors.toList;

import java.util.Collection;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.function.Supplier;
import java.util.stream.IntStream;

import javax.annotation.concurrent.ThreadSafe;

import lombok.SneakyThrows;

@ThreadSafe
public interface ObjectPool<T> {

    static <T> ObjectPool<T> createObjectPool(
            int numberOfObjects,
            Supplier<T> objectFactory) {
        return new ArrayBlockingQueueObjectPool<>(numberOfObjects, objectFactory);
    }

    T borrowObject();

    void returnObject(T borrowed);

    class ArrayBlockingQueueObjectPool<T> implements ObjectPool<T> {
        private final BlockingQueue<T> bench;

        private ArrayBlockingQueueObjectPool(
                int numberOfObjects,
                Supplier<T> objectFactory) {
            bench = new ArrayBlockingQueue<>(numberOfObjects, true, createObjectsCollection(numberOfObjects, objectFactory));
        }

        private Collection<T> createObjectsCollection(
                int numberOfObjects,
                Supplier<T> objectFactory) {
            return IntStream.range(1, numberOfObjects)
                            .mapToObj(i -> objectFactory.get())
                            .collect(toList());
        }

        @SneakyThrows
        public T borrowObject() {
            return bench.take();
        }

        public void returnObject(T borrowed) {
            bench.offer(borrowed);
        }
    }
}