設計模式之單件模式

今天我們來看一下單件模式，這個模式是所有模式中類圖最簡單的哦！

為什么用單件模式：

           有些對象我們只需要一個，比如：連接池、緩存、對話框、和注冊表對象、日志對

           象等對象。事實上，這類對象只能有一個實例，如果制造出多個實例，就會導致許

           多問題產生，例如：程序的行為異常、資源使用過量，或者是不一致的結果。也就

          是為了防止多次 New 對象。

從一個簡單的單件模式入門：

 

public class Singleton {
    private static Singleton uniqueInstance;
 
    // other useful instance variables here
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
 
    // other useful methods here
    public String getDescription() {
        return "I'm a thread safe Singleton!";
    }
}

 

在這里主要注意的點有：

               第二行：利用一個靜態變量來記錄Singleton類的唯一實例；

               第六行：把構造器聲明為私有的，只有字Singleton類內才可以調用構造器；

               第八行至第十三行：用getInstance()方法實例化對象並返回這個示例（如果

                                             uniqueInstance是空的則利用私有構造器產生一個Sin-

                                             gleton實例，否則表示已經有了實例，並將uinqueIns-

                                             tance當返回值）。

讓我們寫一個測試類（Main.java）：

public class Main {

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.getDescription());

    }
}

結果展示：

 

單件模式：確保一個類只有一個實例，並提供一個全局訪問點。

好啦，我們從上面的示例簡單學習了單件模式；現在讓我們來看一個更加復雜的示例

（巧克力工廠）：

public class ChocolateBoiler {
    private boolean empty;
    private boolean boiled;
  
    private ChocolateBoiler() {
        empty = true;    //剛開始鍋爐是空的
        boiled = false;
    }

    public void fill() {
        if (isEmpty()) { //在鍋爐內填入原料時，鍋爐必須是空的。一旦填入原料，就把empty和boiled標志設置好
            empty = false; 
            boiled = false;
            //在鍋爐內填滿巧克力和牛奶的混合物
        }
    }
 
    public void drain() {//鍋爐排出時，必須是滿的（不可以是空的）而且是煮沸過的。排出完畢后，吧empty設置為true
        if (!isEmpty() && isBoiled()) {
            // 排出煮沸的巧克力和牛奶
            empty = true;
        }
    }
 
    public void boil() { //煮混合物時，鍋爐必須是滿的，並且是沒有煮過的。一旦煮沸后，就把boiled設為true
        if (!isEmpty() && !isBoiled()) {
            // 將爐內物煮沸
            boiled = true;
        }
    }
  
    public boolean isEmpty() {
        return empty;
    }
 
    public boolean isBoiled() {
        return boiled;
    }
}

我們在有意識地防止不好的事情發生，但是如果同時存在兩個ChocolateBoiler實例，

可能就會發生很糟糕的事情哦！

所以我們把這個類設計成單件：

public class ChocolateBoiler {
    private boolean empty;
    private boolean boiled;
    private static ChocolateBoiler uniqueInstance;
  
    private ChocolateBoiler() {
        empty = true;
        boiled = false;
    }
  
    public static ChocolateBoiler getInstance() {
        if (uniqueInstance == null) {
            System.out.println("Creating unique instance of Chocolate Boiler");
            uniqueInstance = new ChocolateBoiler();
        }
        System.out.println("Returning instance of Chocolate Boiler");
        return uniqueInstance;
    }

    public void fill() {
        if (isEmpty()) {
            empty = false;
            boiled = false;
            // fill the boiler with a milk/chocolate mixture
        }
    }
 
    public void drain() {
        if (!isEmpty() && isBoiled()) {
            // drain the boiled milk and chocolate
            empty = true;
        }
    }
 
    public void boil() {
        if (!isEmpty() && !isBoiled()) {
            // bring the contents to a boil
            boiled = true;
        }
    }
  
    public boolean isEmpty() {
        return empty;
    }
 
    public boolean isBoiled() {
        return boiled;
    }
}

測試類（Main.java）:

public class ChocolateController {
    public static void main(String args[]) {
        ChocolateBoiler boiler = ChocolateBoiler.getInstance();
        boiler.fill();
        boiler.boil();
        boiler.drain();

        // 將返回已存在的實例，也就是boiler
        ChocolateBoiler boiler2 = ChocolateBoiler.getInstance();
    }
}

 

我們現在模仿了第一個項目，把它做成了單件，但是現在的這個類完美嗎？不！當然

不完美，這不問題出現了：這個機器竟然允許在加熱的時候繼續加原料。

我們現在化身為JVM老看看問題出在哪里吧：

 

現在讓我們開始解決問題，處理多線程（延遲同步，讀完下面按段話就懂嘍）：

方法①：

public class Singleton {
    private static Singleton uniqueInstance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }

    //其他代碼
}

第六行：通過增加synchronized關鍵字到getInstance()方法中，我們迫使每個線程在

進入這個方法之前，要先等候別的線程離開該方法。也就是說，不會有兩個線程可同時

進入這個方法。

 

但是，我們是否能改善多線程呢？

      方法②（使用“急切”創建實例，而不是延遲實例的方法）：

public class Singleton {
    private static Singleton uniqueInstance = new Singleton();

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        return uniqueInstance;
    }

    //其他代碼
}

        方法③（雙重檢查加鎖，在getInstance()中減少使用同步）：

public class Singleton {
    private volatile static Singleton uniqueInstance； 

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (uniqueInstance == null) {
            synchronized(Singleton.class){
               if(uniqueInstance == null){
                   uniqueInstance = new Singleton();
               }
            }
        }
        return uniqueInstance;
    }

    //其他代碼
}

注：volatile關鍵詞確保：當uniqueInstance變量被初始化成Singleton實例時，多個

       縣城正確的處理uniqueInstance變量。

我們現在來對比一下三個方法：

       方法①同步getInstance方法：

                  這是保證可行的最直接的做法，對於巧克力鍋爐似乎沒有性能的考慮，所

                  以可以用這個方法

       方法②急切實例化：

                 我們一定需要用到一個巧克力鍋爐，所以靜態的初始化實力並不是不行的。

                 雖然對於采用標准模式的開發人員來說，此做法可能稍微陌生一點兒。但也

                 是可行的。

       方法③雙重檢查加鎖：

                 由於沒有性能上的考慮，所以這個方法似乎殺雞用了牛刀。另外，采用這個方法還得確定使用的是Java5以上的版本。