Tengo este fragmento de código y quiero un buen método para detener los subprocesos de los consumidores:
import java.util.ArrayDeque; import java.util.Queue; import java.util.concurrent.atomic.AtomicBoolean; public class Foo { private final Queue<Object> queue; private final AtomicBoolean doneReading; private final int numberOfThreads = 4, N = 100; public Foo() { queue = new ArrayDeque<>(); doneReading = new AtomicBoolean(false); } public void execute() throws InterruptedException { Thread[] threads = new Thread[numberOfThreads]; for (int i = 0; i < numberOfThreads; i++) { threads[i] = new Thread(() -> { try { synchronized (queue) { while (!doneReading.get() || !queue.isEmpty()) { if (queue.isEmpty()) { queue.wait(); if (!queue.isEmpty()) { Object element = queue.remove(); // Do stuff } } else { Object element = queue.remove(); // Do stuff } } } } catch (Exception e) { e.printStackTrace(); } }); threads[i].start(); } for (int i = 0; i < N; i++) { synchronized (queue) { queue.add(new Object()); queue.notifyAll(); } } doneReading.set(true); synchronized (queue) { queue.notifyAll(); } for (Thread thread : threads) { thread.join(); } } }Básicamente, cuando he leído todos los datos que deben procesarse, quiero que se detengan los subprocesos de consumo. Intenté while(!doneReading.get()) pero esto no garantiza que no haya elementos sobrantes en la cola. Agregué !queue.isEmpty(), pero en este caso algunos subprocesos siguen esperando a pesar de que no recibirán ninguna notificación. Así que me las arreglé para llamar a notificar a Todos () una vez más. Esto parece funcionar. También pensé en agregar un nulo en la cola, y cada vez que el consumidor lee un nulo, sale del tiempo. ¿Qué método es mejor, o hay mejores ideas?
Un método habitual es una "píldora de veneno". Ponga un valor especial en la cola que, cuando se lea, elimine los subprocesos del consumidor. Esto les permite procesar todos los valores y no detenerse hasta que pasan el valor final y leen la píldora venenosa.
Más información: https://java-design-patterns.com/patterns/poison-pill/
También me gustan estos sitios web, a menudo tienen información detallada sobre programación Java:
class LimitedQueue<T> { ArrayDeque<T> queue = new ArrayDeque<>(); boolean done = false; synchronized void add (T item) { queue.add(item); notifyAll(); } synchronized void done() done=true; notifyAll(); } // most complex method // waits until next item or done signal is put synchronized boolean isDone() { for (;;) { if (!queue.isEmpty(){ return false; } if (done) { return true; } wait(); } } syncronized T remove() { return deque.remove(); } } LimitedQueue<Object> queue = new LimitedQueue<>(); class ConsumerThread extends Thread { public void run(){ while (!queue.isDone()) { Object element = queue.remove(); // do stuff } } } class ProducerThread extends Thread { public void run() { for (int i = 0; i < N; i++) ,{ queue.add(new Object()); } queue.done(); } }