单例模式与static修饰变量实现类数据共享对比(机器人对话)

问题：咱们常常会遇到这样的问题--手机两端的两我的a和b，有一天a有事要向b打电话，可是恰巧b不在服务区。那么如何在b回到服务区的时候立刻就能了解到a遇到的急事。现实生活中咱们会采用电话留言的方式来解决这个问题。在b不在服务区的时候，a向b留言一段话，在b回到服务区的时候经过留言能第一时间了解。

抽象：问题中的a和b两我的就能够模拟为两个线程，a向b传递了一个参数，b接收到以后又向a回了一个参数。本问题也能够理解为线程之间的通讯。

要点：同步

static共享

1，建立须要共享消息的实体massage

package aaa;

public class massage {
    /*a是否向b传了一段消息，1/0  是/否 */
    public static int aFromB=0;
    /*b是否向a传了一段消息，1/0  是/否 */
    public static int bFromA=0;
    /*a向b传递的消息*/
    public static String aMassage;
    /*b向a传递的消息*/
    public static String bMassage;


    public static int getaFromB() {
        return aFromB;
    }
    public static void setaFromB(int aFromB) {
        massage.aFromB = aFromB;
    }
    public static int getbFromA() {
        return bFromA;
    }
    public static void setbFromA(int bFromA) {
        massage.bFromA = bFromA;
    }
    public static String getaMassage() {
        return aMassage;
    }
    public static void setaMassage(String aMassage) {
        massage.aMassage = aMassage;
    }
    public static String getbMassage() {
        return bMassage;
    }
    public static void setbMassage(String bMassage) {
        massage.bMassage = bMassage;
    }



}

2，建立a对象

package aaa;

public class aObj extends massage implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub

        aMassage="真的好想你";
        System.out.println("a说："+aMassage);
        aFromB=1;
        int i=0;
        while(bFromA==0){
            if(i==0){
             System.out.println("a忐忑的等着回复");
            }
            i++;
        }

        aMassage="世界那么大，其实只有你";
        System.out.println("a说："+aMassage);
        aFromB=1;

    }
    public void start(){
        Thread s=new Thread(this);
        s.start();
    }

}

3，建立b对象

package aaa;

public class bObj extends massage implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        int i=0;
        while(aFromB==0){
            if(i==0){
              System.out.println("b看着a的灰色头像发着呆");
            }
            i++;
        }

        bMassage="有多想呀";
        System.out.println("b说："+bMassage);
        aFromB=0;
        bFromA=1;

    }
    public void start(){
        Thread s=new Thread(this);
        s.start();
    }

}

4，执行

package aaa;

public class mains {
    public static void main(String[] args) {

            // TODO Auto-generated constructor stub
            new bObj().start();
            new aObj().start();


    }
}

5，结果

原理分析：咱们应当发现a实体和b实体都继承自消息实体，在建立实体a和b的时候，会自动实例化父类。所以来讲，a和b有两个不一样的父类的对象，可是为何他们之间“能够互传消息”呢？这实际上是一个假象 其实他们并无互传消息，what？由于消息类的变量是static修饰，工做机制是这样的，当实例化a的时候自动实例了一个a消息父类，这个时候会建立static变量，将变量与内存地址关联。当实例化b的时候，实例了一个b消息父类，请注意这个时候将再也不建立变量而是直接将以前的地址赋给了这个变量，所以，a和b中更改变量值其实实在直接更改了内存地址上的值。

单例模式共享

1，建立消息实体类

package aaa;

public class massage {
    private static massage s=new massage();
    public static massage getObj(){
        return s;
    }
    /*a是否向b传了一段消息，1/0  是/否 */
    public int aFromB=0;
    /*b是否向a传了一段消息，1/0  是/否 */
    public int bFromA=0;
    /*a向b传递的消息*/
    public String aMassage;
    /*b向a传递的消息*/
    public String bMassage;

    public int getaFromB() {
        return aFromB;
    }
    public void setaFromB(int aFromB) {
        this.aFromB = aFromB;
    }
    public int getbFromA() {
        return bFromA;
    }
    public void setbFromA(int bFromA) {
        this.bFromA = bFromA;
    }
    public String getaMassage() {
        return aMassage;
    }
    public void setaMassage(String aMassage) {
        this.aMassage = aMassage;
    }
    public String getbMassage() {
        return bMassage;
    }
    public void setbMassage(String bMassage) {
        this.bMassage = bMassage;
    }


}

2，建立a对象

package aaa;

public class aObj extends massage implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub

        massage.getObj().setaMassage("真的好想你");
        System.out.println("a说："+massage.getObj().getaMassage());
        massage.getObj().setaFromB(1);
        int i=0;
        while(massage.getObj().getbFromA()==0){
            if(i==0){
             System.out.println("a忐忑的等着回复");
            }
            i++;
        }

        massage.getObj().setaMassage("世界那么大，其实只有你");
        System.out.println("a说："+massage.getObj().getaMassage());
        massage.getObj().setaFromB(1);;

    }
    public void start(){
        Thread s=new Thread(this);
        s.start();
    }

}

3，建立b对象

package aaa;

public class bObj extends massage implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        int i=0;
        while(massage.getObj().getaFromB()==0){
            if(i==0){
              System.out.println("b看着a的灰色头像发着呆");
            }
            i++;
        }

        massage.getObj().setbMassage("有多想呀");
        System.out.println("b说："+massage.getObj().getbMassage());
        massage.getObj().setaFromB(0);
        massage.getObj().setbFromA(1);

    }
    public void start(){
        Thread s=new Thread(this);
        s.start();
    }

}

4，运行

package aaa;

public class mains {
    public static void main(String[] args) {

            // TODO Auto-generated constructor stub
            new bObj().start();
            new aObj().start();


    }
}

5，结果

原理分析：相比较与static共享数据，单例模式共享更加符合逻辑，由于单例模式在共享数据的过程当中始终是在用一个massage对象，使用一个对象，即是共用一个做用域来进行消息交换