Java BlockingQueue of Size = 1?
-
03-07-2019 - |
Domanda
Essenzialmente quello che voglio è una BlockingQueue di dimensione = 1. Ho un "ascoltatore" thread che attende semplicemente, bloccando fino a quando un oggetto non viene inserito nella coda e quindi lo recupera - e un "produttore" thread che effettivamente inserisce l'oggetto nella coda.
Posso implementarlo con alcuni blocchi sincronizzati e un'implementazione BlockingQueue, ma sembra eccessivo. Esiste un modo migliore e più semplice per fare ciò che voglio?
Esempio di interfaccia:
public interface Wait<T> {
/**
* If "put" has never been called on this object, then this method will
* block and wait until it has. Once "put" has been called with some T, this
* method will return that T immediately.
*/
public T get() throws InterruptedException;
/**
* @param object The object to return to callers of get(). If called more
* than once, will throw an {@link IllegalStateException}.
*/
public void put(T object);
}
Soluzione 2
Ho trovato il codice per una classe chiamata " ObjectLatch " qui: http://forums.sun.com/thread.jspa?threadID=5321141
package jfco.progs;
import java.util.concurrent.CountDownLatch;
/**
* <H1>A Blocking Object Latch</H1> This class implements a blocking object
* latch, that acts as a synchronizer between a producer of an object and it's
* consumer(s).
* <p>
* An object is set with <code>set()</code>only ONCE. Further attempts to set
* the object are just ignored.<br>
* <p>
* Consumers request the object with <code>get()</code>. If the object is not
* already set, consumers are blocked waiting until the object is available or <br>
* until an interrupt (InteruptedException) terminates the wait.
* <p>
* The latch can be tested for object availability with isAvailable(), which
* answers true if the object has already been set. <br>
*/
public class ObjectLatch<R> {
/** The object. */
private R object = null;
/** The latch counter created and set to 1. */
private final CountDownLatch latch = new CountDownLatch(1);
/**
* Checks if the object is already available (has been already set).
*
* @return true, if the object is already available (has been already set)
*/
public boolean isAvailable() {
return latch.getCount() == 0;
}
/**
* Sets the object if it is not already set. Otherwise ignore this request.
*
* @param object
* the object
*/
public synchronized void set(R object) {
if (!isAvailable()) {
this.object = object;
latch.countDown();
}
}
/**
* Get the object if it is already available (has already been set).
* <p>
* If it is not available, wait until it is or until an interrupt
* (InterruptedException) terminates the wait.
*
* @return the object if it is already available (has already been set)
*
* @throws InterruptedException
*/
public R get() throws InterruptedException {
latch.await();
synchronized (this) {
return object;
}
}
}
Altri suggerimenti
Intendi qualcosa come SynchronousQueue ? Un'altra classe utile è Scambiatore
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow