son - posicionar objetos en java

¿Funciona este grupo básico de objetos de Java?

Question

¿Funciona el siguiente grupo de objetos básicos? Tengo uno más sofisticado basado en la misma idea (es decir, mantener tanto un Semaphore como una BlockingQueue). Mi pregunta es: ¿necesito tanto Semaphore como BlockingQueue? ¿Tengo razón en que no necesito hacer ninguna sincronización?

import java.util.Collection;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Semaphore;
public final class Pool<T> {
private final BlockingQueue<T> objects;
private final Semaphore permits;
public Pool(Collection<? extends T> objects) {
// we have as many permits as objects in our pool:
this.permits = new Semaphore(objects.size());
this.objects = new ArrayBlockingQueue<T>(objects.size(), false, objects);
}
public T borrow() {
this.permits.acquireUninterruptibly();
// we have a permit, so there must be one in there:
return this.objects.poll();
}
public void giveBack(T object) {
this.objects.add(object);
this.permits.release();
}
}

Answer 1

Como se ha señalado, un BlockingQueue limitado solo sería suficiente. Por ejemplo, el siguiente código hará lo que quieras:

import java.util.Collection;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public final class Pool<T> {
private final BlockingQueue<T> objects;
public Pool(Collection<? extends T> objects) {
this.objects = new ArrayBlockingQueue<T>(objects.size(), false, objects);
}
public T borrow() throws InterruptedException {
return this.objects.take();
}
public void giveBack(T object) throws InterruptedException {
this.objects.put(object);
}
}

Además, es posible que desee considerar el soporte de una versión cronometrada de borrow () usando BlockingQueue.poll ().

Si no tiene una estructura de datos de cola de bloqueo limitada, puede imponer un semáforo sobre cualquier estructura de datos para crear un comportamiento seguro y vinculado a subprocesos.

Answer 2

Tal vez deberías comprobar que los objetos existen, eso es lo único que tengo.

Editar: No leí el código con tanto cuidado. Así que edtied la publicación un poco. :(

Answer 3

Utilice take () en lugar de poll () y put () en lugar de add (). El semáforo es entonces completamente redundante, así que puedes deshacerte de él. Pero sí, eso se ve bien.

Answer 4

No vale la pena que un ArrayBlockingQueue cree un objeto cuando tomas una entrada de él. Por lo tanto, su grupo de servidores no guardará objetos. Solo podría ayudar si tus objetos son caros de crear.

Answer 5

Un ejemplo de sjlee algo modificado; permitiendo la creación de objetos caros a pedido. Mi caso no requirió ninguna facilidad de bloqueo, por lo tanto, he reemplazado esto con el tipo de cola sin bloqueo. Como beneficio, no es necesario tratar con InterruptedExceptions.

import java.util.Collection;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
public abstract class ObjectPool<T> {
private final Queue<T> objects;
public ObjectPool() {
this.objects = new ConcurrentLinkedQueue<T>();
}
public ObjectPool(Collection<? extends T> objects) {
this.objects = new ConcurrentLinkedQueue<T>(objects);
}
public abstract T createExpensiveObject();
public T borrow() {
T t;
if ((t = objects.poll()) == null) {
t = createExpensiveObject();
}
return t;
}
public void giveBack(T object) {
this.objects.offer(object); // no point to wait for free space, just return
}
}

Answer 6

Tal vez usar una pila en lugar de una cola? Esto da la oportunidad de obtener un objeto que aún está en el caché del procesador.

Answer 7

Aquí hay un grupo más simple y completo para este último. Es mejor que el más simple, y es simple.

De aquí

/**
*
* @see <a href=http://www.javacodegeeks.com/2013/08/simple-and-lightweight-pool-implementation.html>simple pool</>
*/
abstract static class ObjectPool<T>
{
private ConcurrentLinkedQueue<T> pool;
private ScheduledExecutorService executorService;
/**
* Creates the pool.
*
* @param minIdle minimum number of objects residing in the pool
*/
public ObjectPool(final int minIdle)
{
// initialize pool
initialize(minIdle);
}
/**
* Creates the pool.
*
* @param minIdle minimum number of objects residing in the pool
* @param maxIdle maximum number of objects residing in the pool
* @param validationInterval time in seconds for periodical checking of minIdle / maxIdle conditions in a separate thread.
* When the number of objects is less than minIdle, missing instances will be created.
* When the number of objects is greater than maxIdle, too many instances will be removed.
*/
public ObjectPool(final int minIdle, final int maxIdle, final long validationInterval)
{
// initialize pool
initialize(minIdle);
// check pool conditions in a separate thread
executorService = Executors.newSingleThreadScheduledExecutor();
executorService.scheduleWithFixedDelay(new Runnable()
{
@Override
public void run()
{
int size = pool.size();
if (size < minIdle)
{
int sizeToBeAdded = minIdle - size;
for (int i = 0; i < sizeToBeAdded; i++)
{
pool.add(createObject());
}
} else if (size > maxIdle)
{
int sizeToBeRemoved = size - maxIdle;
for (int i = 0; i < sizeToBeRemoved; i++)
{
pool.poll();
}
}
}
}, validationInterval, validationInterval, TimeUnit.SECONDS);
}
/**
* Gets the next free object from the pool. If the pool doesn''t contain any objects,
* a new object will be created and given to the caller of this method back.
*
* @return T borrowed object
*/
public T borrowObject()
{
T object;
if ((object = pool.poll()) == null)
{
object = createObject();
}
return object;
}
/**
* Returns object back to the pool.
*
* @param object object to be returned
*/
public void returnObject(T object)
{
if (object == null)
{
return;
}
this.pool.offer(object);
}
/**
* Shutdown this pool.
*/
public void shutdown()
{
if (executorService != null)
{
executorService.shutdown();
}
}
/**
* Creates a new object.
*
* @return T new object
*/
protected abstract T createObject();
private void initialize(final int minIdle)
{
pool = new ConcurrentLinkedQueue<T>();
for (int i = 0; i < minIdle; i++)
{
pool.add(createObject());
}
}
}