I am trying to implement the Multiple Producer-Consumer problem. I have made the buffer as the lock to maintain consistency of the system. Does this system actually implement multithreading? How can I improve the system using wait
and notify
?
Producer.java
import java.util.*;
import java.io.*;
class Producer extends Thread
{
private Buffer buffer;
private String name;
Producer(Buffer buffer,String name)
{
this.buffer = buffer;
this.name = name;
}
@Override
public void run()
{
while(true)
{
Random r = new Random();
int x = r.nextInt(100);
produce(x);
try
{
//(r.nextInt(6)+1)*
Thread.sleep(100);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
public void produce(int x)
{
synchronized(buffer)
{
if(buffer.size()==buffer.cap)
{
System.out.println("QF");
}
else
{
buffer.add(x);
System.out.println(name+": "+x);
}
}
}
}
Buffer.java
class Buffer
{
private Vector<Integer> buffer;
int cap;
Buffer(int cap)
{
buffer = new Vector<Integer>();
this.cap = cap;
}
int size()
{
return buffer.size();
}
boolean isEmpty()
{
return buffer.isEmpty();
}
void add(int x)
{
buffer.add(x);
}
int remove()
{
if(buffer.isEmpty())
return -1;
int x = buffer.firstElement();
buffer.remove(buffer.firstElement());
return x;
}
}
Consumer.java
class Consumer extends Thread
{
private Buffer buffer;
private String name;
Consumer(Buffer buffer,String name)
{
this.buffer = buffer;
this.name = name;
}
@Override
public void run()
{
while(true)
{
consume();
try
{
Random r = new Random();
Thread.sleep(100);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
public void consume()
{
synchronized(buffer)
{
int x = buffer.remove();
if(x==-1)
{
System.out.println("QE");
}
else
{
System.out.println(name+": "+x);
}
}
}
}
App.java
public class App
{
public static void main(String args[]){
Buffer b = new Buffer(5);
Producer p = new Producer(b,"P1");
Producer p2 = new Producer(b,"P2");
Consumer c = new Consumer(b,"C1");
p.start();
p2.start();
c.start();
}
}