單例模式

下面給大家分享面試必問8大設計模式中的第三種:單例模式

大家如果被面試官問到單例模式,只需回答下面的內容,並分析其中的幾個關鍵點即可.

單例模式分兩類:

• 1.開發使用餓漢式

• 2.但是懶漢式是必須會寫的

  要求解釋未加鎖版的缺陷,和解決方法(加鎖)-並解釋兩個判斷的用意

程式碼以及講解詳情:

/**
 * 餓漢式
 */
 class Sigleton_E {
    //私有化,靜態物件,外界拿不到
    private static final Sigleton_E s = new Sigleton_E();

    //"私有化"建構函式,外界不能建立
 

    private Sigleton_E() {
    }

    //提供公共,靜態的方法獲取例項,不管怎麼樣獲取的都是上面new好的
    public static Sigleton_E getInstance() {
        return s;
    }
}

/**
 * 懶漢式,注意需要解決執行緒安全問題
 */
 class Sigleton_L {
    //私有化,靜態物件,外界拿不到
    private static Sigleton_L s = null;//先宣告引用,不建立

    //"私有化"建構函式,外界不能建立
    private Sigleton_L
 
() {
    }

    //提供公共,靜態的方法獲取例項
    public static Sigleton_L getInstance() {
        if(s==null){
            s = new Sigleton_L();
        }
        return s;
    }
}
/**
 * 改裝版,加上鎖
 */
 class Sigleton_L_L {
    //私有化,靜態物件,外界拿不到
    private static Sigleton_L_L s = null;//先宣告引用,不建立

    //"私有化"建構函式,外界不能建立
    private
 
 Sigleton_L_L() {
    }

    //提供公共,靜態的方法獲取例項,+雙重判斷
    public static Sigleton_L_L getInstance() {
        //為空,單執行緒鎖住,第二次不為空就進不來了
        if (s == null) {
            synchronized (Sigleton_L_L.class) {
                //還為空,就建立,
                //1.多個執行緒的時候,如果s==null,同時多個進來,那麼碰到鎖,只能一個再進這層,為空就建立,建立完畢
                //2.建立完畢後,s!=null,再到剛剛進到鎖面前的其他執行緒,再進來一個,發現不是null了,所以不建立
                if (s == null) {
                    s = new Sigleton_L_L();
                }
            }
        }
        //不為空就返回第一次那個
        return s;
    }
}
//測試類:  
public class Test {
    public static void main(String[] args) {
        /*--------------非多執行緒情況--------------*/
        /*--------------餓漢式-----------------*/
        Sigleton_E e1 = Sigleton_E.getInstance();//不能new而是通過公共方法獲取
        Sigleton_E e2 = Sigleton_E.getInstance();
        System.out.println(e1);
        System.out.println(e2);//列印結果:是同一個物件,標準單例.
        *--------------未改裝版懶漢式-----------------*/
        Sigleton_L l1 = Sigleton_L.getInstance();
        Sigleton_L l2 = Sigleton_L.getInstance();
        System.out.println(l1);
        System.out.println(l2);//列印結果:同一個物件,符合.
        /*--------------改裝版懶漢式-----------------*/
        Sigleton_L_L ll1 =Sigleton_L_L.getInstance();
        Sigleton_L_L ll2 =Sigleton_L_L.getInstance();
        System.out.println(ll1);
        System.out.println(ll2);//發現兩個列印的是:是同一個物件
        /*------------多執行緒版本--------------*/
    }
}

列印結果:

--------------------餓漢式----------------------
[email protected]
[email protected]
--------------------未改裝版懶漢式----------------------
[email protected]
[email protected]
--------------------裝版懶漢式----------------------
[email protected]
[email protected]

下面我們來測試多執行緒情況下的問題:

• 首先餓漢式:

public class Single_E {

        private static Single_E s = new Single_E();

        private Single_E() {
        }
        public static Single_E getInstance() {
            return s;
        }

    public static void main(String[] args) {
        //開啟十個執行緒,方便看出物件的情況
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Single_E s = Single_E.getInstance();
                    System.out.println(s);
                }
            }).start();
        }
    }
}

列印結果:

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
全部一樣,證明餓漢式執行緒安全

• 未改裝版懶漢式:

public class Single_L {

        private static Single_L s = null;

        private Single_L() {
        }

        public static Single_L getInstance() {
            //既然這裡是最容易出現的問題,那麼我們就在模擬
            if (s == null) {
                //一個執行緒進入後,先休眠,然後其他執行緒相繼進入if判斷語句
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //這樣就得到多個結果了
                s = new Single_L();
            }
            return s;
        }

    public static void main(String[] args) {
        //開啟十個執行緒,方便看出物件的情況
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Single_L s = Single_L.getInstance();
                    System.out.println(s);
                }
            }).start();
        }
    }
}

列印結果:

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
各個物件不同,說明"懶漢式"非再裝版執行緒不安全

• “改裝版懶漢式”

public class Single_L_L {

    private static Single_L_L s = null;

    private Single_L_L() {
    }

    public static Single_L_L getInstance() {
        if (s == null) {
            try {
                //同樣模擬一個進來
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 加鎖
            synchronized (Single_L_L.class) {
                if (s == null) {
                    s = new Single_L_L();
                }
            }
        }
        return s;
    }

    public static void main(String[] args) {
        // 開啟十個執行緒,方便看出物件的情況
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Single_L_L s = Single_L_L.getInstance();
                    System.out.println(s);
                }
            }).start();
        }
    }
}

列印結果:

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
得出結論:"改裝版(加鎖版)的懶漢式"是執行緒安全的.

使用拓展

開發的時候我們經常用到很多工具類,絕大部分工具類都不會做成單例,那麼如果我想做成單例的話,一個類中的內部類和同級的外部類呼叫單例工具時將會只是一個單例,使用其中的方法將會是疊加的.所以一般工具類不做成單例,除非是設計資料方面細節問題.

下面舉兩個例子:

包下的Test1類:

public class Test1 {
    public static void main(String[] args) {
        /*--------------第一次使用工具--------------*/
        SingleTool s = SingleTool.getInstance();
        System.out.println("s1 = "+s);
        s.add(123);
        s.add(true);
        s.add("abc");
        s.sout();
        /*--------------第二次使用工具--------------*/
        SingleTool s2 = SingleTool.getInstance();
        System.out.println("s2 = "+s2);
        /*--------------"同一個程式中"另一類(內部類)裡再使用工具--------------*/
        Test1_in.use();
        /*--------------"同一個程式中"另一類(同級)再使用工具--------------*/
        Test1_1.meth();
        /*--------------"同包下"的類使用工具--------------*/
        Test2.use();
    }
    //內部類
    static class Test1_in {
        static void use() {
            SingleTool s = SingleTool.getInstance();
            System.out.println("s3 = "+s);
            s.sout();
        }
    }
}
//同級外部類
class Test1_1 {
    static void meth() {
        SingleTool s = SingleTool.getInstance();
        System.out.println("s4 = "+s);
    }
}

列印結果:

s1 = com.company.[email protected]
123
true
abc
s2 = [email protected]
s3 = [email protected]
123
true
abc
s4 = [email protected]
s : [email protected]
123
true
abc
OK

說明:一個類中呼叫了同個工具類中的各個類,使用的工具是一樣的(單例) ,換成非單例的就不一樣了.

包下的另一個Test2類:

public class Test2 {
    public static void use(){
        SingleTool s = SingleTool.getInstance();
        System.out.println("s : "+s);
        s.add("OK");
        s.sout();
    }
}
class My {
    public static void main(String[] args) {
        /*--------------"同級別類"用工具--------------*/
        Test2.use();
        /*--------------"自己類使用工具"--------------*/
        SingleTool s = SingleTool.getInstance();
        System.out.println(" s : 自己"+s);
        s.sout();
    }
}

列印結果:

s : [email protected]
OK
 s : 自己[email protected]
OK

結論和上面一樣;除非不同的程式(有各自的main)呼叫單例,才不會是同一個物件(符合)

安卓拓展:

• (啟動後,各個頁面得到的單例都會是唯一一個)
• 1.如果介面曾經使用過單例工具,那麼即使這個頁面銷燬(沒有完全退出程式時),再次跳轉過去,將還會是原來的單例.

• 2.除非是棧底完全退出時銷燬,如”滑動預覽任務退出”“(返回鍵退到桌面不代表完全銷燬).

• 原理其實多個活動介面都是”相當於存在一個main中“,他們相當於一個類中”同級別的類”而已這樣就可以用過java剛才了例子來理解這些介面了.