private Queue<T> pool;

private final int minSize;

private final int maxSize;

private final long validationInterval;

private final AtomicReference<Worker> schedulerWorker;

public ObjectPool() {

this(0, 0, 67);

}

/**

private ObjectPool(final int min, final int max, final long validationInterval) {

this.minSize = min;

this.maxSize = max;

this.validationInterval = validationInterval;

this.schedulerWorker = new AtomicReference<Worker>();

// initialize pool

initialize(min);

start();

}

/**

public T borrowObject() {

T object;

if ((object = pool.poll()) == null) {

object = createObject();

}

return object;

}

/**

public void returnObject(T object) {

if (object == null) {

return;

}

this.pool.offer(object);

}

/**

@Override

public void shutdown() {

Worker w = schedulerWorker.getAndSet(null);

if (w != null) {

w.unsubscribe();

}

}

@Override

public void start() {

Worker w = Schedulers.computation().createWorker();

if (schedulerWorker.compareAndSet(null, w)) {

w.schedulePeriodically(new Action0() {

@Override

public void call() {

int size = pool.size();

if (size < minSize) {

int sizeToBeAdded = maxSize - size;

for (int i = 0; i < sizeToBeAdded; i++) {

pool.add(createObject());

}

} else if (size > maxSize) {

int sizeToBeRemoved = size - maxSize;

for (int i = 0; i < sizeToBeRemoved; i++) {

// pool.pollLast();

pool.poll();

}

}

}

}, validationInterval, validationInterval, TimeUnit.SECONDS);

} else {

w.unsubscribe();

}

}

/**

protected abstract T createObject();

private void initialize(final int min) {

if (UnsafeAccess.isUnsafeAvailable()) {

pool = new MpmcArrayQueue<T>(Math.max(maxSize, 1024));

} else {

pool = new ConcurrentLinkedQueue<T>();

}

for (int i = 0; i < min; i++) {

pool.add(createObject());

}

}

}