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

迈不过友情╰ 2023-10-14 05:01 69阅读 0赞

## 线程协作/线程通信 ##

### 管程法 ###

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

![在这里插入图片描述][fea602ada18d40cd94112740645616fa.png]

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

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;
        }
    
    }

[fea602ada18d40cd94112740645616fa.png]: https://img-blog.csdnimg.cn/fea602ada18d40cd94112740645616fa.png