Simple lightweight object pool

public interface Pool<T> {

    T borrowItem() throws PoolDepletionException, InterruptedException;
    void returnItem(T item);

}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

public abstract class AbstractPool<T> implements Pool<T> {

    private final BlockingQueue<T> queue;
    private final Supplier<T> supplier;
    private final long maxWait;
    private final int minIdle;
    private final int maxIdle;

    protected AbstractPool(Supplier<T> supplier) {
        this(supplier, 1, Integer.MAX_VALUE, 0);
    }

    protected AbstractPool(Supplier<T> supplier, int minIdle, int maxIdle, long maxWait) {

        if (minIdle < 0 || minIdle >= maxIdle) {
            throw new IllegalArgumentException("minIdle must be non-negative, and also strictly less than maxIdle");
        }

        this.supplier = supplier;
        this.minIdle = minIdle;
        this.maxIdle = maxIdle;
        this.queue = new LinkedBlockingQueue<>(maxIdle);
        this.maxWait = maxWait;

        // Set up a feed of input values.
        if (this.minIdle > 0) {
            lazyAdd(this.minIdle);
        }
    }

    public int getMinIdle() {
        return minIdle;
    }

    public int getMaxIdle() {
        return maxIdle;
    }

    public int getCurrentIdle() {
        return queue.size();
    }

    /**
     * lazyAdd will start a background thread to add instances to the queue (if
     * possible). The cost of creating a thread is assumed to be insignificant
     * compared to the cost of creating the instance.
     * 
     * @param count
     *            the number of items to add to the pool
     */
    private void lazyAdd(final int count) {
        Runnable toRun = () -> {
            for (int i = 0; i < count; i++) {
                if (!queue.offer(supplier.get())) {
                    return;
                }
            }
        };
        Thread t = new Thread(toRun);
        t.setDaemon(true);
        t.start();
    }

    @Override
    public void returnItem(T item) {
        if (item == null) {
            return;
        }
        queue.offer(item);
    }

    @Override
    public T borrowItem() throws PoolDepletionException, InterruptedException {
        T got = queue.poll();

        // regardless of other things, add a lazy instance if the current state
        // is too low.
        if (queue.size() < minIdle) {
            lazyAdd(1);
        }

        if (got != null) {
            return got;
        }
        if (maxWait > 0) {
            // Try again but block until there's something available.
            // The lazy add above may be the instance we pull out!
            // It is also possible that some other thread may steal the one we
            // added!
            got = queue.poll(maxWait, TimeUnit.MILLISECONDS);

        }
        if (got != null) {
            return got;
        }

        return handleDepleted(supplier);
    }

    @Override
    public String toString() {
        return String.format("Pool with %d items and min %d, max 

import java.util.function.Supplier;

public class SlowStringPool extends AbstractPool<String> {

    public SlowStringPool() {
        super(buildSupplier(), 10, 20, 99);
    }

    private static Supplier<String> buildSupplier() {
        return () -> {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // nothing
            }
            return String.valueOf(System.currentTimeMillis());
        };
    }

    public SlowStringPool(Supplier<String> supplier) {
        super(supplier);
    }

    @Override
    protected String handleDepleted(Supplier<String> supplier) throws PoolDepletionException {
        throw new PoolDepletionException();
    }

    public static void main(String[] args) throws InterruptedException, PoolDepletionException {
        SlowStringPool mypool = new SlowStringPool();
        Thread.sleep(2000);
        int i = 0;
        while (true) {
            long start = System.nanoTime();
            String s = mypool.borrowItem();
            long durn = System.nanoTime() - start;
            System.out.printf("%4d -> %s in %10.3fms -> %s\n", i++, s, durn / 1000000.0, mypool.toString());
            if (i % 2 == 0) {
                mypool.returnItem(s);
            }
        }
    }

}