多线程间之间的通信

image.png

• Input（往内存数据）与Output（往外取数据）线程不一样。

/*
需求：有一堆媒，有一卡车来拉煤，还有一卡车送煤来；
分析：煤堆就是一个对象；一辆卡车就是一个线程。

类似的：一个仓库，存放注册者的姓名和性别，分别有注册和输出两个线程。
*/
class Res{
    
    String name;
    String sex;
}
class Input implements Runnable{
    private Res r;    //不搞对象，直接引用。这里也可以用单例实现！
    Input(Res r){
        this.r = r;
    }
    public void run(){
        int x = 0;
        while(true){
            if(x == 0){
                r.name = "mike";
                r.sex = "man";
            }
            else{
                r.name = "Lily";
                r.sex = "woman";
            }
            x = (x+1)%2;
        }
    } 
}
class Output implements Runnable{
    private Res r ;
    Output(Res r){
        this.r = r;
    }
    public void run(){
        while(true){
            System.out.println(r.name+" "+r.sex);
        }
    } 
}
class InputOutputDemo{
    public static void main(String[] args){
        Res r = new Res();
        Input in = new Input(r);
        Output ou = new Output(r);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(ou);

        t1.start();
        t2.start();
    } 
}

• 结果：

  
  image.png
  • 可以看出两个线程沟通不够，存在安全问题。
  • 究其原因：就是没有加锁，两个线程分别争抢执行赋值和打印代码，刚赋值完姓名还没赋值性别就被打印了，从而出现姓名性别错乱问题。
• 解决办法

/*
需求：有一堆媒，有一卡车来拉煤，还有一卡车送煤来；
分析：煤堆就是一个对象；一辆卡车就是一个线程。

类似的：一个仓库，存放注册者的姓名和性别，分别有注册和输出两个线程。
*/
class Res{
    
    String name;
    String sex;
}
class Input implements Runnable{
    private Res r;    //不搞对象，直接引用。这里也可以用单例实现！
    Input(Res r){
        this.r = r;
    }
    public void run(){
        int x = 0;
        while(true){
            synchronized(Input.class)  //之所以用Input.class作为对象，而没有用其他比如Object类对象，是因为保证两个线程使用的是同一个锁！
                if(x == 0){                       //其实这里用 r 比较合适，r也是唯一的。
                    r.name = "mike";
                    r.sex = "man";
                }
                else{
                    r.name = "Lily";
                    r.sex = "woman";
                }
                x = (x+1)%2;    
            }
        }
    } 
}
class Output implements Runnable{
    private Res r ;
    Output(Res r){
        this.r = r;
    }
    public void run(){
        while(true){
            synchronized(Input.class){    //添加锁，解决代码同步问题。
                System.out.println(r.name+" "+r.sex);
            }
        }
    } 
}
class InputOutputDemo{
    public static void main(String[] args){
        Res r = new Res();
        Input in = new Input(r);
        Output ou = new Output(r);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(ou);

        t1.start();
        t2.start();
    } 
}

• 但现在，还有问题：并没有实现输入一个后就不能再次输入，只有仓库里面有注册者时才可以输出；
• 下面进行解决：我们可以设置一个flag来标示仓库里面有没有资源！同时设置等待、唤醒让两个线程接替执行同步代码块，防止死锁；

wait():

notiyf():

notiyfAll():唤醒全部线程。

• 都使用在同步中，因为要对监视器（锁）的线程操作。
  所以要使用在同步中，因为只有同步才有锁。

为什么这些操作线程的方法要定义Object类中呢？

• 任意对象能定义的方法只能定义在上帝（Object）类中，任意对像都继承Object类。
• 因为这些方法在操作同步中的线程时，都必须要标识它们锁操作的线程只有一个锁，
• 只有同一个锁上的被等待的线程，可以被同一个锁上notify唤醒。
• 不可对不同的锁中的线程进行唤醒。
• 也就是说，等待和唤醒必须是同一个锁。
• 而锁可以时任意对象，所以可以被任意对象调用的方法定义Object类中。

   /*
需求：有一堆媒，有一卡车来拉煤，还有一卡车送煤来；
分析：煤堆就是一个对象；一辆卡车就是一个线程。

类似的：一个仓库，存放注册者的姓名和性别，分别有注册和输出两个线程。
*/
class Res{
    
    String name;
    String sex;
    boolean flag = false;    //设置flag来表示仓库里面有没有资源。
}
class Input implements Runnable{
    private Res r;    //不搞对象，直接引用。这里也可以用单例实现！
    Input(Res r){
        this.r = r;
    }
    public void run(){
        int x = 0;
        while(true){
            synchronized(r){    
                if(r.flag)    //使用wait(),notify()交替执行，保证输入、输出两个线程交替执行，不会出现死锁的问题！
                    try{r.wait();} catch(Exception e){}    //wait()方法在Object类中，不在Thread()类中！Thread继承了Object类的。
                if(x == 0){
                    r.name = "mike";
                    r.sex = "man";
                }
                else{
                    r.name = "Lily";
                    r.sex = "woman";
                }
                x = (x+1)%2;
                r.flag = true;
                r.notify();    //唤醒线程池中的线程，一般是线程池里的第一个线程。    
            }
        }
    } 
}
class Output implements Runnable{
    private Res r ;
    Output(Res r){
        this.r = r;
    }
    public void run(){
        while(true){
            synchronized(r){    //添加锁，解决代码同步问题。
                if(!r.flag)
                    try{r.wait();} catch(Exception e){}
                System.out.println(r.name+" "+r.sex);
                r.flag = false;
                r.notify();
            }
        }
    } 
}
class InputOutputDemo{
    public static void main(String[] args){
        Res r = new Res();
        Input in = new Input(r);
        Output ou = new Output(r);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(ou);

        t1.start();
        t2.start();
    } 
}

• 结果：完全OK了！！！！

• • image.png

• 代码优化（代码优化是程序建设中非常关键的一步，不能偷懒！）：

class Res{     //set()和out()都是对本类对象。
    String name;
    String sex;
    boolean flag = false;
    public synchronized void set(String name, String sex){
        if(this.flag)    
            try{this.wait();} catch(Exception e){}    
        this.name = name;
        this.sex = sex;
        this.flag = true;
        this.notify();    
    }
    public synchronized void out(){
        if(!this.flag)
            try{this.wait();} catch(Exception e){}
        System.out.println(this.name+" "+this.sex);
        this.flag = false;
        this.notify();
    }
}
class Input implements Runnable{
    private Res r;    //对象引用，不创建对象，对象由外面导入。
    Input(Res r){
        this.r = r;
    }
    public void run(){
        int x = 0;
        while(true){
            if(x == 0){
                r.set("mike","man");
            }
            else{
                r.set("Lily","woman");
            }
            x = (x+1)%2;
        }
    } 
}
class Output implements Runnable{
    private Res r ;
    Output(Res r){
        this.r = r;
    }
    public void run(){
        while(true){
            r.out();
        }
    } 
}
class InputOutputDemo1{
    public static void main(String[] args){
        Res r = new Res();
        new Thread(new Input(r)).start();    //线程对象都用匿名对象类创建对象，启动线程。
        new Thread(new Output(r)).start();
    } 
}