Cola de bloqueo de Java que contiene solo elementos únicos

Question

tipo de un "conjunto de bloqueo". ¿Cómo puedo implementar una cola de bloqueo donde se ignora agregar un miembro que ya está en el conjunto?

Answer 1

Puede anular los métodos de agregar y poner de cualquier implementación de BlockingQueue<T> para verificar primero si el elemento ya está dentro de la cola, p.

@Override 
public boolean add(T elem) { 
    if (contains(elem)) 
     return true; 
    return super.add(elem); 
} 

Answer 2

Puede crear una nueva clase que componga una BlockingQueue, un Set y un candado. Cuando pones() pruebas contra el conjunto mientras mantienes un bloqueo que impide que se ejecute get(). Cuando obtiene(), elimina el elemento del conjunto para que pueda volver a colocarse() en el futuro.

Answer 3

class BlockingSet extends ArrayBlockingQueue<E> { 
    /*Retain all other methods except put*/ 
    public void put(E o) throws InterruptedException { 
     if (!this.contains(o)){ 
     super.put(o); 
     } 
    } 
} 

Answer 4

Una implementación cola de bloqueo respaldado por un conjunto de hash vinculados por el orden de iteración predecible y constante de tiempo Además, la eliminación y contiene operaciones:

There you go.

Answer 5

escribí esta clase para resolver un problema similar:

/** 
* Linked blocking queue with {@link #add(Object)} method, which adds only element, that is not already in the queue. 
*/ 
public class SetBlockingQueue<T> extends LinkedBlockingQueue<T> { 

    private Set<T> set = Collections.newSetFromMap(new ConcurrentHashMap<>()); 

    /** 
    * Add only element, that is not already enqueued. 
    * The method is synchronized, so that the duplicate elements can't get in during race condition. 
    * @param t object to put in 
    * @return true, if the queue was changed, false otherwise 
    */ 
    @Override 
    public synchronized boolean add(T t) { 
     if (set.contains(t)) { 
      return false; 
     } else { 
      set.add(t); 
      return super.add(t); 
     } 
    } 

    /** 
    * Takes the element from the queue. 
    * Note that no synchronization with {@link #add(Object)} is here, as we don't care about the element staying in the set longer needed. 
    * @return taken element 
    * @throws InterruptedException 
    */ 
    @Override 
    public T take() throws InterruptedException { 
     T t = super.take(); 
     set.remove(t); 
     return t; 
    } 
}