java 的單例設計模式

概念：
　　java中單例模式是一種常見的設計模式，單例模式分三種：懶漢式單例、餓漢式單例、登記式單例三種。
　　單例模式有以下特點：
　　1、單例類只能有一個實例。
　　2、單例類必須自己創建自己的唯一實例。
　　3、單例類必須給所有其他對象提供這一實例。
　　單例模式確保某個類只有一個實例，而且自行實例化並向整個系統提供這個實例。在計算機系統中，線程池、緩存、日誌對象、對話框、打印機、顯卡的驅動程序對象常被設計成單例。這些應用都或多或少具有資源管理器的功能。每臺計算機可以有若干個打印機，但只能有一個Printer Spooler，以避免兩個打印作業同時輸出到打印機中。每臺計算機可以有若干通信端口，系統應當集中管理這些通信端口，以避免一個通信端口同時被兩個請求同時調用。總之，選擇單例模式就是爲了避免不一致狀態，避免政出多頭。

一、懶漢式單例

//懶漢式單例類.在第一次調用的時候實例化自己
public class Singleton {
    //私有的默認構造子
    private Singleton() {}
    //注意，這裏沒有final
    private static Singleton single=null;
    //靜態工廠方法
    public static Singleton getInstance() {
         if (single == null) {
             single = new Singleton();
         }
        return single;
    }
}

Singleton通過將構造方法限定爲private避免了類在外部被實例化，在同一個虛擬機範圍內，Singleton的唯一實例只能通過getInstance()方法訪問。

（事實上，通過Java反射機制是能夠實例化構造方法爲private的類的，那基本上會使所有的Java單例實現失效。此問題在此處不做討論，姑且掩耳盜鈴地認爲反射機制不存在。）

但是以上懶漢式單例的實現沒有考慮線程安全問題，它是線程不安全的，併發環境下很可能出現多個Singleton實例，下面介紹的餓漢式單例是線程安全的。

二、餓漢式單例

//餓漢式單例類.在類初始化時，已經自行實例化
public class Singleton1 {
    //私有的默認構造子
    private Singleton1() {}
    //已經自行實例化
    private static final Singleton1 single = new Singleton1();
    //靜態工廠方法
    public static Singleton1 getInstance() {
        return single;
    }
}

餓漢式在類創建的同時就已經創建好一個靜態的對象供系統使用，以後不再改變，所以是線程安全的。

三、登記式單例

//類似Spring裏面的方法，將類名註冊，下次從裏面直接獲取。
public class Singleton3 {
    private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();
    static{
        Singleton3 single = new Singleton3();
        map.put(single.getClass().getName(), single);
    }
    //保護的默認構造子
    protected Singleton3(){}
    //靜態工廠方法,返還此類惟一的實例
    public static Singleton3 getInstance(String name) {
        if(name == null) {
            name = Singleton3.class.getName();
            System.out.println("name == null"+"--->name="+name);
        }
        if(map.get(name) == null) {
            try {
                map.put(name, (Singleton3) Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
    //一個示意性的商業方法
    public String about() {
        return "Hello, I am RegSingleton.";
    }
    public static void main(String[] args) {
        Singleton3 single3 = Singleton3.getInstance(null);
        System.out.println(single3.about());
    }
}

 登記式單例實際上維護了一組單例類的實例，將這些實例存放在一個Map（登記薄）中，對於已經登記過的實例，則從Map直接返回，對於沒有登記的，則先登記，然後返回。 

餓漢式和懶漢式區別

這兩種乍看上去非常相似，其實是有區別的，主要兩點

1、線程安全：

餓漢式是線程安全的，可以直接用於多線程而不會出現問題，懶漢式就不行，它是線程不安全的，如果用於多線程可能會被實例化多次，失去單例的作用。

如果要把懶漢式用於多線程，有兩種方式保證安全性，一種是在getInstance方法上加同步，另一種是在使用該單例方法前後加雙鎖。

2、資源加載：

餓漢式在類創建的同時就實例化一個靜態對象出來，不管之後會不會使用這個單例，會佔據一定的內存，相應的在調用時速度也會更快，

而懶漢式顧名思義，會延遲加載，在第一次使用該單例的時候纔會實例化對象出來，第一次掉用時要初始化，如果要做的工作比較多，性能上會有些延遲，之後就和餓漢式一樣了。

什麼是線程安全？

如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。

或者說：一個類或者程序所提供的接口對於線程來說是原子操作，或者多個線程之間的切換不會導致該接口的執行結果存在二義性,也就是說我們不用考慮同步的問題，那就是線程安全的。

應用

以下是一個單例類使用的例子，以懶漢式爲例：

public class TestSingleton {
    String name = null;

        private TestSingleton() {
    }

    private static TestSingleton ts = null;

    public static TestSingleton getInstance() {
        if (ts == null) {
            ts = new TestSingleton();
        }
        return ts;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void printInfo() {
        System.out.println("the name is " + name);
    }

}

public class TMain {
    public static void main(String[] args){
        TestStream ts1 = TestSingleton.getInstance();
        ts1.setName("jason");
        TestStream ts2 = TestSingleton.getInstance();
        ts2.setName("0539");

        ts1.printInfo();
        ts2.printInfo();

        if(ts1 == ts2){
            System.out.println("創建的是同一個實例");
        }else{
            System.out.println("創建的不是同一個實例");
        }
    }
}

 運行結果：

結論：由結果可以得知單例模式爲一個面向對象的應用程序提供了對象惟一的訪問點，不管它實現何種功能，整個應用程序都會同享一個實例對象。

轉自：http://blog.csdn.net/jason0539/article/details/23297037