Java多线程——线程协助之生产者消费者问题&程管法&信号灯法

线程协助

生产者消费者模式（非设计模式）

• Object 提供的几个方法

方法	作用
wait()	表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout)	等待指定毫秒数
notify()	唤醒一个正在等待的线程
notifyAll()	唤醒同一个对象上所有调用wait方法的线程，优先级别高的线程先调度

• 生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据（管程法）

• 信号灯法

• 生产消费问题(管程法)

package com.thread.demo;

public class Demo21 {
    public static void main(String[] args) {
        ChickenContainer chickenContainer = new ChickenContainer();
        Consumers consumers = new Consumers(chickenContainer);
        Producers producers = new Producers(chickenContainer);
        consumers.start();
        producers.start();

    }
}

class Chicken {
    private int id;  // 产品编号

    public int getId() {
        return id;
    }

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


//生产者
class Producers extends Thread {
    private ChickenContainer container;

    public Producers(ChickenContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        // 生产鸡
        for (int i = 1; i <= 100; i++) {
            Chicken chicken = new Chicken(i);
            try {
                System.out.println("生产者生产了第"+i+"只鸡");
                this.container.addChicken(chicken);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者
class Consumers extends Thread {
    private ChickenContainer container;

    public Consumers(ChickenContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        //吃鸡
        for (int i = 1; i <= 100; i++) {
            try {
                System.out.println("消费者吃了第" + this.container.eatChicken() + "只鸡");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}


//Container 容器
class ChickenContainer {

    private Chicken[] chickensContainer = new Chicken[10]; //容器大小
    private int count = 0; // 当前容器中鸡的数量

    public synchronized void addChicken(Chicken chicken) throws InterruptedException {
        if (count==chickensContainer.length) {
//            如果容器满了生产等待
            this.wait();
        }
//        如果没有满就生产鸡
        chickensContainer[count] = chicken;
        count++;

        //通知消费者消费
        this.notifyAll();
    }

    public synchronized int eatChicken() throws InterruptedException {
        if (count == 0) {
//            通知生产者生产
            this.notifyAll();
//            等待生产
            this.wait();
        }
        count--;
        int id = chickensContainer[count].getId();
        return id;
    }
}

• 生产消费问题(信号灯法)

package com.thread.demo;

public class Demo22 {
    public static void main(String[] args) {
        Lights lights = new Lights();
        new Persons(lights).start();
        new Cars(lights).start();
    }
}

//行人
class Persons extends Thread{
    private Lights lights ;

    public Persons(Lights lights) {
        this.lights = lights;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                boolean ret = this.lights.personRun();
                if (ret){
                    System.out.println("行人通行，汽车等待");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//汽车
class Cars extends Thread{
    private Lights lights ;

    public Cars(Lights lights) {
        this.lights = lights;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                boolean ret = this.lights.carRun();
                if (ret){
                System.out.println("汽车通行,行人等待");}

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//信号灯
class Lights{
    private boolean flag = true;  //代表行车红灯行人绿灯，false代表行人红灯，行车绿灯

    public synchronized boolean carRun() throws InterruptedException {
        Thread.sleep(100);
        if (this.flag){
//            行车红灯，行人绿灯，汽车等待
            this.wait();
        }
        this.notifyAll();
        this.flag = !this.flag; //行车通过，置换型号灯
        return true;
    }

    public  synchronized boolean personRun() throws InterruptedException {
        Thread.sleep(100);
        if (!this.flag){
//            行人红灯，行车绿灯，行人等待
            this.wait();
        }
        this.notifyAll();
        this.flag = !this.flag; //置换型号灯
        return true;
    }
}