幾種單例模式實現方式及其優缺點分析

什么是單例模式

確保一個類只有一個實例，也就是類有且僅有一個對象，並且提供一個全局的訪問點，外部通過這個訪問點來訪問該類的唯一實例

單例模式的特點

1. 單例類只能有一個實例；
2. 單例類必須自己創建自己的唯一實例；
3. 單例類必須給所有其他對象提供這一實例。

幾種常見的單例模式

單例模式的寫法有好幾種，這里主要介紹四種：懶漢式單例、餓漢式單例、登記式單例、枚舉式單例

懶漢式單例

不着急實例化，需要用的時候才初始化

原始式

public class Singleton {
    private Singleton() {}
    private static Singleton singleton = null;
    public static Singleton getInstance() {
         if (singleton== null) {  
             singleton= new Singleton();
         }  
        return singleton;
    }
}

缺點：

1. 在反射面前沒什么用，因為java反射機制是能夠實例化構造方法為private的類的；
2. 線程不安全，因為線程訪問具有隨機性，並發環境可能出現多個singleton實例

線程同步式

public class Singleton {
    private Singleton() {}
    private static Singleton singleton = null;

    //為了保證多線程環境下正確訪問，給方法加上同步鎖synchronized
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

缺點：在方法調用上加了同步，雖然線程安全了，但是每次都有同步，會影響性能，畢竟99%是不需要同步的

雙重鎖檢查式

public class Singleton {
    private Singleton() {}
    private static Singleton singleton = null;

    //雙重鎖檢查
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton3();
                }
            }
        }
        return singleton;
    }
}

優點：線程安全，且確保了只有第一次調用單例時才會做同步，避免了每次都同步的性能損耗；
缺點：雙重鎖降低了程序響應速度和性能

靜態內部類式

public class Singleton {
    private Singleton() {}

    //內部類的初始化需要依賴主類，需要先等主類實例化之后，內部類才能開始實例化
    private static class LazyHolder {
        //這里加final是為了防止內部將這個屬性覆蓋掉
        private static final Singleton INSTANCE = new Singleton();
    }

    //這里加final是為了防止子類重寫父類
    public static final Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

優點：利用了classloader機制來保證初始化instance時只有一個線程，線程安全且沒有性能損耗

餓漢式

類初始化的時候就立刻實例化，天生線程安全

public class Singleton {
    private Singleton() {}
    private static final Singleton singleton = new Singleton();
    public static Singleton getInstance() {
        return singleton;
    }
}

缺點：系統啟動時，占用資源；如果后期這個單例沒有被使用，會造成資源浪費

注冊登記式

• 相當於有一個容器裝載所有實例，在實例產生之前先檢查下容器有沒有，如果有就直接取出來，如果沒有就先new一個放進去，然后給后面的人用，SpringIoc容器就是一種注冊登記式單例
• 登記式單例實際上維護了一種單例類的實例，將這些實例存放在一個Map中，對於已經登記過的實例，則從Map直接返回，沒有登記的，則先登記，然后返回；
• 登記式單例內部實現其實還是用的餓漢式，因為其中的static方法塊，它的的單例在類被裝載時就被實例化了

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 注冊登記式單例
 * 類似Spring里面的方法，將類名注冊，下次從里面直接獲取
 */
public class Singleton {
    //Spring最底層的這個容器就是一個map，說白了，IOC容器就是一個map
    private static Map<String, Singleton> map = new ConcurrentHashMap<String, Singleton>();

    //每個class對應一個map的key，也就是唯一的id
    static {
        Singleton singleton = new Singleton();
        map.put(singleton.getClass().getName(), singleton);
    }

    //保護默認構造函數
    protected Singleton() {}

    //靜態工廠方法，返回此類唯一的實例
    public static Singleton getInstance(String name) {
        if (name == null) {
            name = Singleton.class.getName();
        }
        if (map.get(name) == null) {
            try {
                map.put(name, (Singleton) Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
}

枚舉式單例

• 這種方式不僅能解決多線程同步問題，而且能防止反序列化重新創建新的對象，不過由於jdk1.5中才加入enum特性，所以不常用

public enum Singleton {
    INSTANCE;

    public void getInstance() {
    }
}