生产者消费者模式

方法一：   wait()  和   notify()   通信方法实现

1.通过对象锁实现公共容器的同步，即一次只能有一个生产者往容器放产品或是一个消费者取出产品

package Consumerproducer;
public class PublicContainer{
int capaticy=10;
public synchronized void decreate(String name){
while(capaticy==0){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
capaticy--;
System.out.println(name+"\n生产成功，容量还有"+capaticy);
this.notify();
}
public synchronized void increate(String name){
while(capaticy==10){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
capaticy++;
System.out.println(name+"\n消费成功，容量还有"+capaticy);
this.notify();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
PublicContainer publicContainer=new PublicContainer();
Consumer consumer1=new Consumer("consumer1", publicContainer);
Consumer consumer2=new Consumer("consumer2", publicContainer);
Consumer consumer3=new Consumer("consumer3", publicContainer);
Thread c1=new Thread(consumer1);
Thread c2=new Thread(consumer2);
Thread c3=new Thread(consumer3);
Producer producer1=new Producer("producer1", publicContainer);
Producer producer2=new Producer("producer2", publicContainer);
Thread p1=new Thread(producer1);
Thread p2=new Thread(producer2);
c1.start();
c2.start();
c3.start();
p1.start();
p2.start();
}
}
class Consumer implements Runnable{
private String name;
PublicContainer publicContainer;
public Consumer(String name,PublicContainer publicContainer) {
this.name=name;
this.publicContainer=publicContainer;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(1500);
publicContainer.increate(name);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
class Producer implements Runnable{
private String name;
PublicContainer publicContainer;
public Producer(String name,PublicContainer publicContainer){
this.name=name;
this.publicContainer=publicContainer;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(1000);
publicContainer.decreate(name);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

方法二：采用阻塞队列实现生产者消费者模式

1.通过阻塞队列来实现同步，java.util.concurrent中的容器是线程安全的

package Consumerproducer;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class PublicBoxQueue {
public static void main(String[] args) {
// TODO Auto-generated method stub
BlockingQueue publicBoxQueue= new LinkedBlockingQueue(5); 
Consumer2 c1=new Consumer2(publicBoxQueue);
Consumer2 c2=new Consumer2(publicBoxQueue);
Producer2 p1=new Producer2(publicBoxQueue);
Thread t1=new Thread(c1);
Thread t2=new Thread(c2);
Thread t3=new Thread(p1);
t1.start();
t2.start();
t3.start();
}
}
class Consumer2 implements Runnable{
private final BlockingQueue publicBoxQueue;
public Consumer2(BlockingQueue publicBoxQueue){
this.publicBoxQueue=publicBoxQueue;
}
@Override
public void run() {
// TODO Auto-generated method stub
int i=0;
while(true){
try {
Thread.sleep(1500);
System.out.println("消费者消费的苹果编号为 :"+publicBoxQueue.take());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
class Producer2 implements Runnable{
private final BlockingQueue publicBoxQueue;
public Producer2(BlockingQueue publicBoxQueue){
this.publicBoxQueue=publicBoxQueue;
}
@Override
public void run() {
// TODO Auto-generated method stub
int i=0;
while(true){
i++;
try {
Thread.sleep(500);
publicBoxQueue.put(i);
System.out.println("生产者的生产苹果编号为:"+i);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}