文章轉(zhuǎn)載至：http://www.blogjava.net/kenzhh/archive/2013/03/15/357824.html

當(dāng)一個類只需要創(chuàng)建一個實例即可時，則需要使用單例模式。

第一種（懶漢，線程不安全）：

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

這使用的是一種懶加載方式，即當(dāng)需要使用時才去判斷選擇創(chuàng)建；若此時同時有多個調(diào)用就會出現(xiàn)多次創(chuàng)建的問題；因此線程不安全

第二種（懶漢，線程安全）：

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

這種通過加synchronized鎖的方式雖然線程安全，但是效率非常的低。

第三種（餓漢）：

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

這種方式基于classloder機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，雖然導(dǎo)致類裝載的原因有很多種，在單例模式中大多數(shù)都是調(diào)用getInstance方法， 但是也不能確定有其他的方式（或者其他的靜態(tài)方法）導(dǎo)致類裝載，這時候初始化instance顯然沒有達(dá)到的懶加載效果。

第四種（餓漢，變種）：

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

這個和第三種差不多。

第五種（靜態(tài)內(nèi)部類）：

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

這種方式同樣利用了classloder的機制來保證初始化instance時只有一個線程，它跟第三種和第四種方式不同的是（很細(xì)微的差別）：第三種和第四種方式是只要Singleton類被裝載了，那么instance就會被實例化（沒有達(dá)到lazy loading效果），而這種方式是Singleton類被裝載了，instance不一定被初始化。因為SingletonHolder類沒有被主動使用，只有顯示通過調(diào)用getInstance方法時，才會顯示裝載SingletonHolder類，從而實例化instance。想象一下，如果實例化instance很消耗資源，我想讓他延遲加載，另外一方面，我不希望在Singleton類加載時就實例化，因為我不能確保Singleton類還可能在其他的地方被主動使用從而被加載，那么這個時候?qū)嵗痠nstance顯然是不合適的。這個時候，這種方式相比第三和第四種方式就顯得很合理。

第六種（枚舉）：

public class Singleton {
    private Singleton(){}
    public static Singleton getInstance(){
        return SingletonEnum.INSTANCE.getInstance();
    }
    private static enum SingletonEnum{
        INSTANCE;
        private Singleton singleton;
        //JVM會保證此方法絕對只調(diào)用一次
        private SingletonEnum(){
            singleton = new Singleton();
        }
        public Singleton getInstance(){
            return singleton;
        }
    }
}

這種方式是Effective Java作者Josh Bloch 提倡的方式，它不僅能避免多線程同步問題，而且還能防止反序列化重新創(chuàng)建新的對象。但是我目前在實際開發(fā)中還沒看到過這種寫法。

第七種（雙重校驗鎖）：

public class Singleton {
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
        if (null == singleton) {
            synchronized (Singleton.class) {
                if (null == singleton) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

這個是第二種方式的升級版，俗稱雙重檢查鎖定。在JDK1.5之后，雙重檢查鎖定才能夠正常達(dá)到單例效果。

不過好像在高并發(fā)的情況下，可能會出現(xiàn)空對象的問題；即在new對象時，Java虛擬機完全有可能先new出來一個空的未調(diào)用過構(gòu)造函數(shù)的instance對象，然后再將其賦值給instance引用，然后再調(diào)用構(gòu)造函數(shù)，對instance對象當(dāng)中的元素進(jìn)行初始化。當(dāng)還未初始化時正好有個線程在調(diào)用，此時會直接返回，而返回的對象還未被初始化。但是對于普通的一般不會出現(xiàn)此種問題。

不過一般來說，第一種不算單例，第四種和第三種就是一種，如果算的話，第五種也可以分開寫了。所以說，一般單例都是五種寫法。懶漢，惡漢，雙重校驗鎖，枚舉和靜態(tài)內(nèi)部類。