Java-手写生产者消费者模式

package com.it;

/**
 * 手写生产者消费者模式
 */
public class ProduceConsumer {
    public static void main(String[] args) {
        SyncStack ss = new SyncStack();//定义缓冲区对象
        Produce p = new Produce(ss);//定义生产者线程
        Consumer c = new Consumer(ss);//定义消费者线程
        p.start();
        c.start();
    }
}

//馒头类
class Mantou {
    int id;

    public Mantou(int id) {
        this.id = id;
    }
}

class SyncStack {//（缓冲区）馒头筐、push压栈、pop出栈
    int index = 0;
    Mantou[] mantous = new Mantou[10];

    public synchronized void push(Mantou mantou) {
        while (index == mantous.length) {//说明馒头筐满了
            try {
                //wait后，线程会将持有的对象锁释放，进入等待池（等待状态）
                //这样，锁池中的线程就可以竞争获得对象锁
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        this.notify();//唤醒在当前对象等待池中的一个线程，进入当前对象的锁池
        mantous[index] = mantou;
        index++;
    }


    public synchronized Mantou pop(){
        while (index==0){//馒头筐空了，消费线程进入等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        this.notify();
        return mantous[--index];
    }
}

class Produce extends Thread {//生产者线程
    SyncStack ss = null;

    public Produce(SyncStack ss) {
        this.ss = ss;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            Mantou m = new Mantou(i);
            ss.push(m);
            System.out.println("生产者生产馒头："+m.id);
        }
    }
}

class Consumer extends Thread {//消费者线程
    SyncStack ss = null;

    public Consumer(SyncStack ss) {
        this.ss = ss;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            Mantou m = ss.pop();
            System.out.println("消费馒头："+m.id);
        }

    }
}