Me gustaría crear algún tipo de aplicación de subprocesamiento Producer/Consumer. Pero no estoy seguro de cuál es la mejor manera de implementar una cola entre los dos.Producer/Consumer threads using a Queue
Así que tengo algunas ideas (las cuales pueden ser totalmente erróneas). Me gustaría saber cuál sería mejor y si ambos apestan, ¿cuál sería la mejor forma de implementar la cola? Es principalmente mi implementación de la cola en estos ejemplos lo que me preocupa. Extiendo una clase Queue que es una clase interna y es segura para subprocesos. A continuación hay dos ejemplos con 4 clases cada uno.
principal de clase
public class SomeApp
{
private Consumer consumer;
private Producer producer;
public static void main (String args[])
{
consumer = new Consumer();
producer = new Producer();
}
}
Consumidor de clase
public class Consumer implements Runnable
{
public Consumer()
{
Thread consumer = new Thread(this);
consumer.start();
}
public void run()
{
while(true)
{
//get an object off the queue
Object object = QueueHandler.dequeue();
//do some stuff with the object
}
}
}
Productor de clase
public class Producer implements Runnable
{
public Producer()
{
Thread producer = new Thread(this);
producer.start();
}
public void run()
{
while(true)
{
//add to the queue some sort of unique object
QueueHandler.enqueue(new Object());
}
}
}
cola de clase
public class QueueHandler
{
//This Queue class is a thread safe (written in house) class
public static Queue<Object> readQ = new Queue<Object>(100);
public static void enqueue(Object object)
{
//do some stuff
readQ.add(object);
}
public static Object dequeue()
{
//do some stuff
return readQ.get();
}
}
O
principal de clase
public class SomeApp
{
Queue<Object> readQ;
private Consumer consumer;
private Producer producer;
public static void main (String args[])
{
readQ = new Queue<Object>(100);
consumer = new Consumer(readQ);
producer = new Producer(readQ);
}
}
Consumidor de clase
public class Consumer implements Runnable
{
Queue<Object> queue;
public Consumer(Queue<Object> readQ)
{
queue = readQ;
Thread consumer = new Thread(this);
consumer.start();
}
public void run()
{
while(true)
{
//get an object off the queue
Object object = queue.dequeue();
//do some stuff with the object
}
}
}
Productor de clase
public class Producer implements Runnable
{
Queue<Object> queue;
public Producer(Queue<Object> readQ)
{
queue = readQ;
Thread producer = new Thread(this);
producer.start();
}
public void run()
{
while(true)
{
//add to the queue some sort of unique object
queue.enqueue(new Object());
}
}
}
cola de clase
//the extended Queue class is a thread safe (written in house) class
public class QueueHandler extends Queue<Object>
{
public QueueHandler(int size)
{
super(size); //All I'm thinking about now is McDonalds.
}
public void enqueue(Object object)
{
//do some stuff
readQ.add();
}
public Object dequeue()
{
//do some stuff
return readQ.get();
}
}
¡Y listo!
Productores enqueue y Consumer dequeue, btw. No al revés ... –
Ah, y no comiences los hilos de un constructor !! Ese hilo podría observar el objeto en un estado inconsistente. Consulte "Concurrencia de Java en la práctica" para más detalles. –
Gracias Zwei, lo que entré fue que yo estaba desenfocado. el inicio de la tarea Subproceso del constructor ¿debería ejecutar un método de intiliazation y comenzar allí o debería iniciarlo desde la clase de método principal? – Gareth