生产者等待java_等待/通知范式的生产者消费者 java实现

#等待/通知范式的单生产者单消费者模型

package Concurrency;

public class OneProOneCon {

//等待/通知写法的单生产者单消费者模型

public static boolean full=false;

public static void main(String[] args) {

Object lock = new Object();

Consumer c = new Consumer(lock);

Producer p = new Producer(lock);

ThreadC tc = new ThreadC(c);

ThreadP tp = new ThreadP(p);

tp.start();

tc.start();

}

static class Consumer{

private Object lock;

private int count;

Consumer(Object lock){

this.lock=lock;

this.count=0;

}

public void consume(){

try {

synchronized (lock){

while(!full) {

lock.wait();

}

count++;

System.out.println("a consumer consume "+count);

full=false;

lock.notify();

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

static class Producer{

private Object lock;

private int count;

Producer(Object lock){

this.lock =lock;

this.count=0;

}

public void product(){

try {

synchronized (lock){

while(full){

lock.wait();

}

count++;

System.out.println("producer product a thing");

full=true;

lock.notify();

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

static class ThreadP extends Thread{

private Producer producer;

ThreadP(Producer producer){

this.producer = producer;

}

@Override

public void run() {

while(true) {

producer.product();

}

}

}

static class ThreadC extends Thread{

private Consumer consumer;

ThreadC(Consumer consumer){

this.consumer=consumer;

}

@Override

public void run() {

try {

for(int i=0;i<3;i++){

consumer.consume();

Thread.sleep(2000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

#等待/通知范式的多生产者多消费者实现

package Concurrency;

public class MulProMulCon {

//等待/通知模式的多生产者多消费者

public static final int MAXPRODUCTNUM=5;

public static int productLeft=0;

public static void main(String[] args) {

Object lock = new Object();

ThreadC[] tcs = new ThreadC[10];

ThreadP[] tps = new ThreadP[10];

for(int i=0;i<10;i++){

Consumer c = new Consumer(lock,"consumer"+i);

Producer p = new Producer(lock,"producer"+i);

tcs[i] = new ThreadC(c);

tps[i] = new ThreadP(p);

}

for(int i=0;i<10;i++){

tcs[i].start();

}

for(int i=0;i<10;i++){

tps[i].start();

}

}

static class Consumer{

private String name;

private Object lock;

private int count;

Consumer(Object lock,String name){

this.lock=lock;

this.count=0;

this.name=name;

}

public void consume(){

try {

synchronized (lock){

while(productLeft==0) {

lock.wait();

}

count++;

System.out.println(name+" consume a thing");

productLeft--;

lock.notifyAll();

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

static class Producer{

private Object lock;

private String name;

private int count;

Producer(Object lock,String name){

this.lock =lock;

this.count=0;

this.name=name;

}

public void product(){

try {

synchronized (lock){

while(productLeft==MAXPRODUCTNUM){

lock.wait();

}

count++;

System.out.println(name+" product a thing");

productLeft++;

lock.notifyAll();

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

static class ThreadP extends Thread{

private Producer producer;

ThreadP(Producer producer){

this.producer = producer;

}

@Override

public void run() {

while(true) {

producer.product();

}

}

}

static class ThreadC extends Thread{

private Consumer consumer;

ThreadC(Consumer consumer){

this.consumer=consumer;

}

@Override

public void run() {

try {

while(true){

consumer.consume();

Thread.sleep(1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}