关于线程的 管程

关于线程的 管程

引用狂神说

简单的说消费者与生产这互相成为约束，创建缓存区 ，利用缓冲的限制来控制消费者与生产者

生产者

// 生产者
class  Productor extends Thread{
    SynContainer container;
    public  Productor(SynContainer container){
        this.container=container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了"+i+"鸡");
            container.push(new Chicken(i));

        }
    }
}

创建构造函数。引入缓冲，run方法中进行执行函数体，调用缓冲的增加方法

消费者

//消费者
class  Consumer extends Thread{
    SynContainer container;
    public  Consumer(SynContainer container){
        this.container=container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费"+container.pop().id+"鸡");
        }
    }
}

同理消费者，消费者在构造函数中引入缓冲，调用缓冲的减少方法

生产资料

class  Chicken{
    int id;
    public Chicken(int id) {
        this.id=id;

    }
}

关于容器

class SynContainer{
    //容器的大小
    Chicken [] chickens=new Chicken[10];
    //容器计数器
    int count=0;
    //生产者放入产品
    public  synchronized  void push(Chicken chicken){
        //判断容器的清空，满了通知消费，未满继续丢入
        if(count==chickens.length){
            //通知消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        chickens[count]=chicken;
        count++;
        //通知消费这进行消费  激活指定对象上挂起的所有线程
        this.notifyAll();
    }
    //消费者取走产品
    public  synchronized Chicken pop(){
        if(count==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken=chickens[count];
        //通知进行生产，激活等待线程
        this.notifyAll();
        return chicken;
    }

pop 方法与 push 方法互相影响，作为SynContainer其this.notifyAll()激活了对面的wait，挂起线程如此

public class Testpc {
    public static void main(String[] args) {
        SynContainer synContainer=new SynContainer();
        new Productor(synContainer).start();
        new Consumer(synContainer).start();

    }
}

启动完成预期功能

生产了0鸡
生产了1鸡
生产了2鸡
生产了3鸡
生产了4鸡
生产了5鸡
生产了6鸡
生产了7鸡
生产了8鸡
生产了9鸡
生产了10鸡
生产了11鸡
消费0鸡
消费10鸡
生产了99鸡
消费98鸡
消费99鸡
消费7鸡
消费6鸡
消费5鸡
消费4鸡
消费3鸡
消费2鸡
消费1鸡
进程速度差不多导致的结果很有趣（部分截取控制台结果）