生产者与消费者-1：N-基于list

一个生产者/多个消费者：

/**
 *    生产者
 */
public class P {
    
    private MyStack stack;
    
    public P(MyStack stack) {
        this.stack = stack;
    }
    
    public void pushService() {
        stack.push();
    }
}

/**
 *    消费者
 */
public class C {
    
    private MyStack stack;
    
    public C(MyStack stack) {
        this.stack = stack;
    }
    
    public void popService() {
        System.out.println("pop = " + stack.pop());
    }
}

/**
 *    模拟栈
 */
public class MyStack {

    private List<Object> list = new ArrayList<>();
    
    public synchronized void push() {
        try {
            while(list.size() == 1) {
                this.wait();
            }
            list.add(""+Math.random());
            this.notifyAll();
            System.out.println("push:" + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public synchronized String pop() {
        String value = "";
        try {
            while(list.size() == 0) {
                System.out.println("pop 操作中：" + Thread.currentThread().getName() + "wait状态");
                this.wait();
            }
            value = ""+list.get(0);
            list.remove(0);
            this.notifyAll();
            System.out.println("pop:" + list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return value;
    }
}

/**
 *    生产者线程
 */
public class P_Thread extends Thread {
    
    private P p;
    
    public P_Thread(P p) {
        this.p = p;
    }
    
    @Override
    public void run() {
        while (true) {
            p.pushService();
        }
    }
}

/**
 *    消费者线程
 */
public class C_Thread extends Thread {
    
    private C c;
    
    public C_Thread(C c) {
        this.c = c;
    }
    
    @Override
    public void run() {
        while (true) {
            c.popService();
        }
    }
}

/**
 *    测试类
 */
public class Run {

    public static void main(String[] args) {
        MyStack stack = new MyStack();
        //一个生产者
        P p = new P(stack);
        //多个消费者
        C c1 = new C(stack);
        C c2 = new C(stack);
        C c3 = new C(stack);
        
        //一个生产者线程
        P_Thread pThread = new P_Thread(p);
        //多个消费者线程
        C_Thread cThread1 = new C_Thread(c1);
        C_Thread cThread2 = new C_Thread(c2);
        C_Thread cThread3 = new C_Thread(c3);
        
        //启动
        pThread.start();
        cThread1.start();
        cThread2.start();
        cThread3.start();
    }
}

运行结果如下：