线程的管程法跟信号灯法_生产者消费模式

在生产者跟消费模式中常用两种方法来处理并发问题，管程法跟信用灯法

• 管程法：常用一个缓冲区来处理通知唤醒跟等待
• 信号灯法：常用一个标识位来处理唤醒跟等待操作

管程法：

package 多线程练习.锁学习.生产者消费模式;

public class 管程法 {
    public static void main(String[] args) {
        Syncontainer syncontainer = new Syncontainer();
        Producer producer = new Producer(syncontainer);
        Consumer consumer = new Consumer(syncontainer);
        new Thread(producer, "生产者").start();
        new Thread(consumer, "消费者").start();
    }
}


class Chicken {
    int id;

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

class Producer implements Runnable {

    Syncontainer syncontainer;

    public Producer(Syncontainer syncontainer) {
        this.syncontainer = syncontainer;
    }

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

class Consumer implements Runnable {

    Syncontainer syncontainer;

    public Consumer(Syncontainer syncontainer) {
        this.syncontainer = syncontainer;
    }

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

class Syncontainer {
    // 缓冲区最多可以存放10只鸡
    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;
    }
}

管程法输出结果：

信号灯法：

package 多线程练习.锁学习.生产者消费模式;

import org.omg.CORBA.TCKind;

public class 信号灯法 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        Productor02 p = new Productor02(tv);
        Consumer02 c = new Consumer02(tv);
        new Thread(p).start();
        new Thread(c).start();

    }
}

class Productor02 implements Runnable {
    Tv tv;

    public Productor02(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                tv.player("还珠格格");
            } else {
                tv.player("广告时间");
            }
        }

    }
}

class Consumer02 implements Runnable {

    Tv tv;

    public Consumer02(Tv tv) {
        this.tv = tv;
    }


    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.SeeTv();
        }
    }
}

class Tv {
    Boolean flag = true;  // 这就是个信号灯  // 当flag  true 电视播放 观众停止  false：电视停止 观众观看
    String tvName;


    //  观众观看
    public synchronized void SeeTv() {

        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


        System.out.println("观众正在观看电视节目" + this.tvName);

        this.notifyAll(); // 通知player继续播放下个节目

        flag = !flag;

    }


    //电视播放
    public synchronized void player(String tvName) {
        // 观众在观看的试试 不能换台
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("电视机正在播放" + tvName);
        this.tvName = tvName;  //将本地额tvname更新 防止观众看了个寂寞

        this.notifyAll(); // 通知player继续播放下个节目

        flag = !flag;
    }

}

信号灯法输出结果：