Tengo una situación en la que diferentes subprocesos llenan una cola (productores) y un elemento de recuperación del consumidor de esta cola. Mi problema es que cuando uno de estos elementos se recupera de la cola, algunos se pierden (¿falta la señal?). El código de los productores es:

<code>class Producer implements Runnable {

    private Consumer consumer;

    Producer(Consumer consumer) { this.consumer = consumer; }

    @Override
public void run() {
    consumer.send("message");
  }
}
</code>

y son creados y ejecutados con:

<code>ExecutorService executor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 20; i++) {
  executor.execute(new Producer(consumer));
}
</code>

El código del consumidor es:

<code>class Consumer implements Runnable {

private Queue<String> queue = new ConcurrentLinkedQueue<String>();

void send(String message) {
    synchronized (queue) {
        queue.add(message);
        System.out.println("SIZE: " + queue.size());
        queue.notify();
    }
}

@Override
public void run() {
    int counter = 0;
    synchronized (queue) {
    while(true) {
        try {
            System.out.println("SLEEP");
                queue.wait(10);
        } catch (InterruptedException e) {
                Thread.interrupted();
        }
        System.out.println(counter);
        if (!queue.isEmpty()) {             
            queue.poll();
            counter++;
        }
    }
    }
}

}
</code>

Cuando se ejecuta el código, a veces obtengo 20 elementos agregados y 20 recuperados, pero en otros casos los elementos recuperados tienen menos de 20. ¿Alguna idea de cómo solucionarlo?