线程通信模型，原来是这样的！

线程协作

注:需要练习体会

一. 生产者消费者模式–>管程法

角色：生产者、消费者、缓冲区、产品

个人理解：两个线程公用同一个对象，各自再允许的条件范围内做操作，符合对方的条件就唤醒。

//主线程
public class TestMG{
	public static void main(String[] args){
        Basket b = new Basket();
        
        new Girlfriend(b).start();
        new Me(b).start();
    }
} 

class Orange{
    int num;
    public Orange(int num){
        this.num = num;
    }
}

class Girlfriend extends Thread{
    private Bastek b;
    public Girlfriend(Bastek b){
        this.b =b;
    }
    @Override
    public void run(){
        for(int i = 0;i<100 ;i++ ){
			System.out.println("女朋友剥了"+i+"个橘子");
            Orange o = new Orange(i);
            b.push(o);
        }
	}
}

class Me extends Thread{
   Bastek b;
    public Me(Bastek b){
        this.b =b;
    } 
    
    @Override
    public void run(){
		for(int i =0;i<100 ; i++){
            System.out.println("我吃了"+b.pop().num+"个橘子");
        }
    }
}

class Basket{
    Orange[] oranges  = new Orange[10];
    int count ==0;
 //生产者要剥橘子
    public synchronized void push(Orange orange){
        //如果
    	if(count==oragnes.length){
     	   try{
     	       this.wait();
    	    }catch(InterruptedException e){
			 	e.printStackTrace();
    	     }
        }
 	     oranges[count] = orange;
     	 this.notifyAll();
    	 count++
    }   
 //消费者要吃橘子
        public synchronized Orange pop(){
            if(count ==0){
                try{
                    this.wait();
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
            count--;
            Orange orange = oranges[count]; 
            this.notifyAll();
            return orange;
        }
}

二. 信号灯法

角色：生产者、消费者、中介

个人理解：是管程法的简化版，容器只有一个位置，没位置只能消费，有位置只能生产,设置状态位，将原来多个位置缩小到1个

public class TestGM2{
    public static void main(String[] args){
        Led led = new Led();
    
        new Girlfriend(led).start();
        new Me(led).start();
    }
}

class Girlfriend extends Thread{
    Led led;
    public Girlfriend(Led led){
        this.led = led;
    }
    @Override
    public void run(){
        for(int i = 0;i<20;i++ ){
         if(i%2==0){
             this.led.push("橘子");
         }else{
             this.led.push("香蕉");
         }   
        }
    }
}

class Me extends Thread{
 Led led;
    public Me(Led led){
        this.led = led;
    } 
    @Override
    public void run(){
 		for(int i = 0;i<20;i++ ){
            this.led.pop();
        }
    }
}

class Led {
    String o;
    boolean flag = false;
    public synchronized void push(String o){
        if(!flag){
            try{
                this.wait();
            }catch(InterruptedExcuption e){
                e.printStackTrace();
            }
        }
        System.out.println("女友剥了"+s);
        notifyAll();
        this.o =o;
        this.flag = !this.flag;
    
    }
    public synchronized void pop(){
        if(flag){
            try{
                this.wait();
            }catch(InterruptedException e){
                e.ptintStaticTrace();
            }
        }
        System.out.println("我吃了" + this.o);
        notifyAll();
        this.flag = !this.flag;
        
    }
}