线程协作：管程法，信号灯法

线程协作/线程通信

管程法

• 通过一个缓冲区，将部分数据存放在缓冲区中，在由缓冲区中的数据进行判断，对某偶一个线程进行等待或者唤醒。
• 通过 this.wait()，让当前线程等待，并且释放当前线程对象对资源的锁，使得其他的线程可以使用到该资源
• 通过this.notifyAll();对等待的线程进行唤醒，wait()方法使当前线程进入等待状态，同时释放当前对象的锁。当另一个线程调用了相同对象上的notify()（或notifyAll()）方法时，处于等待状态的线程将被唤醒并继续执行，重新尝试获取对象的锁。

使用生产者消费者的问题对管程法进行进一步的解释

1. 创建生产者和消费者相关线程，同时使用使用一个商品资源，创建一个商店缓冲区，对商品资源进行一个临时的存储以及线程之间的交互。
2. 将缓冲区大小设置为10 。可以存储10件商品，当购买者购买是商品时，如果商店缓冲区中商品存在，则卖与消费者同时商品数-1，若没有则，消费者释放对于商品的锁，将资源交由生产者生产，当生产者将商店缓冲区中的商品数目生产到10，或者商品数>0时，通知消费者购买商品，实现线程之间的交互。

• 代码实例：

package com.XianCheng.ImportPort;
/*
    学习线程协作，线程通信——管程法。
        线程协作就是两个线程之间相互的通信，创建一个缓冲区，让两个线程进行交互。
        线程协作的本质就是通过一个 容器，对容器中的数据进行改变，通过wait使得某一个线程等待另一个线程，或者通过本线程对另外一个线程通知，通知另外一个线程运行

    使用商店购买东西当做案例对管程法进行解释
        1.购买者和生产者是两个线程，通过商店对两个线程进行线程通信，即商店就是两个线程用于交互的容器
        2.给商店一个既定的商品，用户购买时，若有则卖与用户，若没有则通知生产者补货，同时在补到一定数量后就停止补货，直到购买者购买商店没有该产品，再次补货
 */
public class TestPC {
    public static void main(String[] args) {
        //创建缓冲区对象
        buffer b = new buffer();
        //线程调用缓冲区，实现线程通信
        new producer(b).start();
        new buyer(b).start();
    }
}
//为商店中的既定的商品进行属性的定义
class Chicken{
    int id;//产品编号
    public Chicken(int id) {
        this.id = id;
    }
}
//创建一个生产者线程
class producer extends Thread{
    //创建缓冲区对象
    buffer con;
    //创建构造方法
    public  producer(buffer con){
    this.con=con;
    }

    @Override
    public void run() {
    //生产者生产100个商品
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了第"+i+"只鸡！");
            con.push(new Chicken(i));

        }
    }
}
//创建一个购买者线程
class buyer extends Thread
{
    //创建缓冲区对象
    buffer con;
    //创建构造方法
    public  buyer(buffer con){
        this.con=con;
    }
    @Override
    public void run() {
        //购买100个商品
        for (int i = 0; i < 100; i++) {
            System.out.println("购买者购买的第————》"+con.pop().id+"只鸡");
        }
    }
}
//创建一个缓冲区,使用缓冲区可以暂时存储线程传输的数据。
class buffer {
    //设置缓冲区大小
    Chicken[] chicken=new Chicken[10];
    //设置一个计数位
    int num=0;
    //生产者生产产品，这个方法需要一个锁去独享缓冲区这个资源
    public synchronized void push(Chicken chickens) {
        //判断是否缓冲区中商品是否满了
        if (num==chicken.length){
            //通知购买者可以购买了，生产者等待购买者购买
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //缓冲区没满，则通知生产者生产
        else {
            //将产品丢入缓冲区中的数组中
            chicken[num]=chickens;
            num++;
            //通知消费者消费
            this.notifyAll();
        }
    }
    //购买者消费
    public  synchronized Chicken pop(){
        //判断缓冲区中还有没有产品
        if (num==0){
            //通知生产者生产,购买者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
            //缓冲区中有产品，可以购买
            System.out.println("num="+num);
            num--;


            //将对应的产品中缓冲区中取出
            Chicken chicken = this.chicken[num];
            //产品购买后就通知生产者生产，可能买一次生产者就生产一次，可能买多次生产者才生产，根据线程的运行实际情况而言
            //返回看买的哪一个产品
            this.notifyAll();
            return chicken;
    }

}

信号灯法

• 信号灯法，通过对标志位的改变实现线程之间的交互。
• 信号灯法不需要使用一个缓冲区对数据进行短暂的存储。即只能一个线程运行一次后就将资源交由另一个线程使用。
• 假设有A，B两个线程，设置一个标志位flag，当标志位flag=true时，运行线程A，线程B等待，反之运行线程B，线程A等待。
• 代码看看，一下明白：

package com.XianCheng.ImportPort;
/*
    学习线程协作：信号灯法，通过对标志位的修改实现线程之间的交互
        以演员和观众为交互的线程
        不需要缓冲区，可直接进行交互
        1. 创建一个生产者线程，一个用户线程，和一个中间物：产品
        2. 设置标志位，根据标志位实现线程之间的切换
 */
public class TestPC2 {
    public static void main(String[] args) {
        //创建产品的类属性
        TV tv = new TV();
        //创建线程对象
        player player = new player(tv);
        watch watch = new watch(tv);
        player.start();
        watch.start();
    }
}
//创建生产者线程:表演者
class player extends Thread{
    //创建TV属性
    TV tv;
    //创建构造方法
    public player(TV tv){
        this.tv=tv;
    }

    //重写run方法
    @Override
    public void run() {
        //表演者表演
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                tv.play("快乐大本营");
            }
            tv.play("广告");
        }
    }
}
//创建用户线程：观众
class watch extends Thread{
    TV tv;
    public watch(TV tv){
        this.tv=tv;
    }

    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //观众观看
            tv.see();
        }
    }
}
//产品：节目
class TV{
    //创建节目属性
    String voice;
    //创建标志位flag，flag=true-》演员表演；flag=FALSE-》观众观看
    Boolean flag=true;
    //创建方法，表演
    public synchronized void play(String voice){
        //判断标志符的值，看线程是否需要等待
        if (!flag){
            //flag=false,演员休息，观众观看
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了"+voice);
        //演员表演了通知观众观看
        this.notifyAll();
        //更新节目
        this.voice=voice;
        //标志位取反
        this.flag=!this.flag;
    }
    //创建方法观看
    public synchronized void see(){
        //判断标志位的值，检查是否有节目可以观看
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了节目："+voice);
        //节目看完了，通知生产者生产，唤醒生产者
        this.notifyAll();
        //标志位取反
        this.flag=!this.flag;
    }

}