單例模式與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對象，使用一個對象，即是共用一個做用域來進行消息交換