Java 設(shè)計(jì)模式單例模式

wall2flower 發(fā)布于2019-08-14 17:13 / 457人閱讀

摘要：單例類如果一個(gè)類始終只能創(chuàng)建一個(gè)實(shí)例，則這個(gè)類被稱為單例類在一些特殊場景下，要求不允許自由創(chuàng)建該類的對象，而只允許為該類創(chuàng)建一個(gè)對象。

單例（Singleton）類

如果一個(gè)類始終只能創(chuàng)建一個(gè)實(shí)例，則這個(gè)類被稱為單例類

在一些特殊場景下，要求不允許自由創(chuàng)建該類的對象，而只允許為該類創(chuàng)建一個(gè)對象。為了避免其他類自由創(chuàng)建該類的實(shí)例，應(yīng)該把該類的構(gòu)造器使用private修飾，從而把該類的所有構(gòu)造器隱藏起來

根據(jù)良好封裝的原則：一旦把該類的構(gòu)造器隱藏起來，就需要一個(gè)public方法作為該類的訪問點(diǎn)，用于創(chuàng)建該類的對象，且該方法必須使用static修飾（因?yàn)檎{(diào)用該方法之前還不存在對象，因此調(diào)用該方法的不可能是對象，只能是類）

除此之外，該類還必須緩存已經(jīng)創(chuàng)建的對象，否則該類無法知道是否曾經(jīng)創(chuàng)建過對象，也就無法保證只創(chuàng)建了一個(gè)對象。為此該類需要使用一個(gè)成員變量來保存曾經(jīng)創(chuàng)建的對象，因?yàn)樵摮蓡T變量需要被上面的靜態(tài)方法訪問，故該成員變量必須使用static修飾

class Singleton
{
    // 使用一個(gè)類變量來緩存曾經(jīng)創(chuàng)建的實(shí)例
    private static Singleton instance;
    // 將構(gòu)造器使用private修飾，隱藏該構(gòu)造器
    private Singleton(){}
    // 提供一個(gè)靜態(tài)方法，用于返回Singleton實(shí)例
    // 該方法可以加入自定義的控制，保證只產(chǎn)生一個(gè)Singleton對象
    public static Singleton getInstance()
    {
        // 如果instance為null，表明還不曾創(chuàng)建Singleton對象
        // 如果instance不為null，則表明已經(jīng)創(chuàng)建了Singleton對象，
        // 將不會(huì)重新創(chuàng)建新的實(shí)例
        if (instance == null)
        {
            // 創(chuàng)建一個(gè)Singleton對象，并將其緩存起來
            instance = new Singleton();
        }
        return instance;
    }
}
public class SingletonTest
{
    public static void main(String[] args)
    {
        // 創(chuàng)建Singleton對象不能通過構(gòu)造器，
        // 只能通過getInstance方法來得到實(shí)例
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // 將輸出true
    }
}

Coding

代碼一：

public class Singleton {  
    private Singleton() {}                     // 關(guān)鍵點(diǎn)0：構(gòu)造函數(shù)是私有的
    private static Singleton single = null;    // 關(guān)鍵點(diǎn)1：聲明單例對象是靜態(tài)的
    public static Singleton GetInstance()      // 通過靜態(tài)方法來構(gòu)造對象
    {                        
         if (single == null)
         {                                     // 關(guān)鍵點(diǎn)2：判斷單例對象是否已經(jīng)被構(gòu)造
             single = new Singleton();  
         }    
        return single;  
    }  
}

代碼一是線程不安全的，遇到多線程的并發(fā)條件下，有可能給new出多個(gè)單例實(shí)例

========================================================================================

代碼二：

public class Singleton {  
    private Singleton() {}                     // 關(guān)鍵點(diǎn)0：構(gòu)造函數(shù)是私有的
    private static Singleton single = null;    // 關(guān)鍵點(diǎn)1：聲明單例對象是靜態(tài)的
    private static Object obj= new Object();
    public static Singleton GetInstance()      // 通過靜態(tài)方法來構(gòu)造對象
    {                        
         if (single == null)                   // 關(guān)鍵點(diǎn)2：判斷單例對象是否已經(jīng)被構(gòu)造
         {                            
            lock(obj)                          // 關(guān)鍵點(diǎn)3：加線程鎖
            {
               single = new Singleton();  
             }
         }    
        return single;  
    }  
}

在關(guān)鍵點(diǎn)2，檢測單例是否被構(gòu)造。雖然這里判斷了一次，但是由于某些情況下，可能有延遲加載或者緩存的原因，只有關(guān)鍵點(diǎn)2這一次判斷，仍然不能保證系統(tǒng)是否只創(chuàng)建了一個(gè)單例，也可能出現(xiàn)多個(gè)實(shí)例的情況

========================================================================================

代碼三：

public class Singleton {  
    private Singleton() {}                     // 關(guān)鍵點(diǎn)0：構(gòu)造函數(shù)是私有的
    private static Singleton single = null;    // 關(guān)鍵點(diǎn)1：聲明單例對象是靜態(tài)的
    private static object obj= new object();
    public static Singleton GetInstance()      // 通過靜態(tài)方法來構(gòu)造對象
    {                        
         if (single == null)                   // 關(guān)鍵點(diǎn)2：判斷單例對象是否已經(jīng)被構(gòu)造
         {                            
            lock(obj)                          // 關(guān)鍵點(diǎn)3：加線程鎖
            {
               if(single == null)              // 關(guān)鍵點(diǎn)4：二次判斷單例是否已經(jīng)被構(gòu)造
               {
                  single = new Singleton();  
                }
             }
         }    
        return single;  
    }  
}

在判斷單例實(shí)例是否被構(gòu)造時(shí)，需要檢測兩次，在線程鎖之前判斷一次，在線程鎖之后判斷一次，再去構(gòu)造實(shí)例

單例模式關(guān)鍵點(diǎn)

單例是為了保證系統(tǒng)中只有一個(gè)實(shí)例，其關(guān)鍵點(diǎn)有：

私有構(gòu)造函數(shù)

聲明靜態(tài)單例對象

構(gòu)造單例對象之前要加鎖（lock一個(gè)靜態(tài)的object對象）

需要兩次檢測單例實(shí)例是否已經(jīng)被構(gòu)造，分別在鎖之前和鎖之后

單例模式問答 為何要檢測兩次？

如上面所述，有可能延遲加載或者緩存原因，造成構(gòu)造多個(gè)實(shí)例，違反了單例的初衷

構(gòu)造函數(shù)能否公有化？

不行，單例類的構(gòu)造函數(shù)必須私有化，單例類不能被實(shí)例化，單例實(shí)例只能靜態(tài)調(diào)用

lock住的對象為什么要是object對象，可以是int嗎？

不行，鎖住的必須是個(gè)引用類型。如果鎖值類型，每個(gè)不同的線程在聲明的時(shí)候值類型變量的地址都不一樣，那么上個(gè)線程鎖住的東西下個(gè)線程進(jìn)來會(huì)認(rèn)為根本沒鎖，相當(dāng)于每次都鎖了不同的門。引用類型的變量地址是相同的，每個(gè)線程進(jìn)來判斷鎖都想是否被鎖的時(shí)候都是判斷同一個(gè)地址，相當(dāng)于是鎖在通一扇門，起到了鎖的作用