Ce pool d'objets Java de base fonctionne-t-il?

La suite de base de l'objet de la piscine de travail? J'en ai une plus sophistiquée basée sur la même idée (c'est à dire maintenir à la fois un Sémaphore et un BlockingQueue). Ma question est ai - je besoin à la fois de Sémaphore et BlockingQueue? Suis-je en droit que je n'ai pas besoin de faire une synchronisation?

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();
    }
}

source d'informationauteur looeeese

  1. 14

    Comme cela a été souligné, bornée BlockingQueue seul serait suffisant. Par exemple, le code suivant va faire ce que vous voulez:

    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);
    }
}

    Aussi, vous pouvez envisager de soutenir un temps de la version d'emprunter() à l'aide de BlockingQueue.poll().

    Si vous n'avez pas bornée file d'attente de blocage structure de données, alors vous pouvez imposer un sémaphore sur le dessus d'une structure de données pour créer un thread safe et lié comportement.

  2. 5

    Un peu modifié sjlee l'exemple; en permettant la création d'objets coûteux sur demande. Mon cas n'a pas besoin bloquant l'installation donc j'ai remplacées par des non-bloquant type de file d'attente. Comme un avantage, il n'y a pas besoin de traiter avec 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
    }
}
  3. 3

    Peut-être utiliser une pile au lieu d'une file d'attente? Cela donne une chance d'obtenir un objet qui est toujours assis dans le cache du processeur.

  4. 2

    Utilisation de() à la place de poll(), et put() au lieu de la méthode add(). Le sémaphore est alors totalement redondante, de sorte que vous pouvez simplement se débarrasser de lui. Mais oui, ça a l'air bon.

  5. 1

    Sa vaut rien qu'un ArrayBlockingQueue crée un objet lorsque vous prenez une entrée. Votre piscine ne sera pas réellement de sauvegarder les objets. Il ne pouvait aider si vos objets sont coûteux à créer.

  6. 0

    Peut-être vous devriez vérifier que l'existence d'objets, c'est la seule chose que j'ai.

    Edit: je n'ai pas lu le code avec soin. J'ai donc edtied le post un peu. 🙁

  7. 0

    Ici est plus simple et complète de la piscine pour les derniers.
    C'est mieux que le plus simple, et c'est simple.

    De ici

    /**
* 
* @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());
}
}
}