實現單例模式的 9 種方法,你知道幾種?

喝水會長肉發表於2021-11-30

一. 什麼是單例模式

因程式需要,有時我們只需要某個類同時保留一個物件,不希望有更多物件,此時,我們則應考慮單例模式的設計。

二. 單例模式的特點

  1. 單例模式只能有一個例項。

  2. 單例類必須建立自己的唯一例項。

  3. 單例類必須向其他物件提供這一例項。

三. 單例模式VS靜態類

在知道了什麼是單例模式後,我想你一定會想到靜態類,“既然只使用一個物件,為何不乾脆使用靜態類?”,這裡我會將單例模式和靜態類進行一個比較。

  1. 單例可以繼承和被繼承,方法可以被override,而靜態方法不可以。

  2. 靜態方法中產生的物件會在執行後被釋放,進而被GC清理,不會一直存在於記憶體中。

  3. 靜態類會在第一次執行時初始化,單例模式可以有其他的選擇,即可以延遲載入。

  4. 基於2, 3條,由於單例物件往往存在於DAO層(例如sessionFactory),如果反覆的初始化和釋放,則會佔用很多資源,而使用單例模式將其常駐於記憶體可以更加節約資源。

  5. 靜態方法有更高的訪問效率。

  6. 單例模式很容易被測試。

幾個關於靜態類的誤解:

誤解一:靜態方法常駐記憶體而例項方法不是。

實際上,特殊編寫的例項方法可以常駐記憶體,而靜態方法需要不斷初始化和釋放。

誤解二:靜態方法在堆(heap)上,例項方法在棧(stack)上。

實際上,都是載入到特殊的不可寫的程式碼記憶體區域中。

靜態類和單例模式情景的選擇:

情景一:不需要維持任何狀態,僅僅用於全域性訪問,此時更適合使用靜態類。

情景二:需要維持一些特定的狀態,此時更適合使用單例模式。

四. 單例模式的實現

  1. 懶漢模式( 執行緒不安全


//java學習交流:737251827  進入可領取學習資源及對十年開發經驗大佬提問,免費解答!

public class SingletonDemo {
    private static SingletonDemo instance ;
    private SingletonDemo ( ) {

    }
    public static SingletonDemo getInstance ( ) {
        if ( instance == null ) {
           instance = new SingletonDemo ( ) ;
        }
        return instance ;
    }
}


如上,通過提供一個靜態的物件instance,利用private許可權的構造方法和getInstance()方法來給予訪問者一個單例。

缺點是,沒有考慮到執行緒安全,可能存在多個訪問者同時訪問,並同時構造了多個物件的問題。之所以叫做懶漢模式,主要是因為此種方法可以非常明顯的lazy loading。

針對懶漢模式執行緒不安全的問題,我們自然想到了,在getInstance()方法前加鎖,於是就有了第二種實現。

  1. 執行緒安全的懶漢模式( 執行緒安全


public 
class 
SingletonDemo 
{

    private static SingletonDemo instance ;
    private SingletonDemo ( ) {

    }
    public static synchronized SingletonDemo getInstance ( ) {
        if (instance == null ) {
           instance = new SingletonDemo ( ) ;
        }
        return instance ;
    }
}


然而併發其實是一種特殊情況,大多時候這個鎖佔用的額外資源都浪費了,這種打補丁方式寫出來的結構效率很低。

  1. 餓漢模式( 執行緒安全


public 
class 
SingletonDemo 
{

    private static SingletonDemo instance = new SingletonDemo ( ) ;
    private SingletonDemo ( ) {

    }
    public static SingletonDemo getInstance ( ) {
        return instance ;
    }
}

直接在執行這個類的時候進行一次loading,之後直接訪問。顯然,這種方法沒有起到lazy loading的效果,考慮到前面提到的和靜態類的對比,這種方法只比靜態類多了一個記憶體常駐而已。

  1. 靜態類內部載入( 執行緒安全


public 
class 
SingletonDemo 
{

    private static class SingletonHolder {
        private static SingletonDemo instance = new SingletonDemo ( ) ;
    }
    private SingletonDemo ( ) {
       System .out . println ( "Singleton has loaded" ) ;
    }
    public static SingletonDemo getInstance ( ) {
        return SingletonHolder .instance ;
    }
}
  1. 使用內部類的好處是,靜態內部類不會在單例載入時就載入,而是在呼叫getInstance()方法時才進行載入,達到了類似懶漢模式的效果,而這種方法又是執行緒安全的。

  2. 列舉方法( 執行緒安全


enum SingletonDemo
{

    INSTANCE ;
    public void otherMethods ( ) {
       System .out . println ( "Something" ) ;
    }
}

Effective Java作者Josh Bloch 提倡的方式,在我看來簡直是來自神的寫法。解決了以下三個問題:

(1)自由序列化。

(2)保證只有一個例項。

(3)執行緒安全。

如果我們想呼叫它的方法時,僅需要以下操作:


public 
class 
Hello 
{

    public static void main ( String [ ] args ) {
       SingletonDemo . INSTANCE . otherMethods ( ) ;
    }
}


這種充滿美感的程式碼真的已經終結了其他一切實現方法了。

Josh Bloch 對這個方法的評價:這種寫法在功能上與共有域方法相近,但是它更簡潔,無償地提供了序列化機制,絕對防止對此例項化,即使是在面對複雜的序列化或者反射攻擊的時候。雖然這中方法還沒有廣泛採用,但是單元素的列舉型別已經成為實現Singleton的最佳方法。列舉單例這種方法問世以來,許多分析文章都稱它是實現單例的最完美方法——寫法超級簡單,而且又能解決大部分的問題。不過我個人認為這種方法雖然很優秀,但是它仍然不是完美的——比如,在需要繼承的場景,它就不適用了。

  1. 雙重校驗鎖法( 通常執行緒安全,低概率不安全


public 
class 
SingletonDemo 
{

    private static SingletonDemo instance ;
    private SingletonDemo ( ) {
       System .out . println ( "Singleton has loaded" ) ;
    }
    public static SingletonDemo getInstance ( ) {
        if (instance == null ) {
            synchronized ( SingletonDemo .class ) {
                if (instance == null ) {
                   instance = new SingletonDemo ( ) ;
                }
            }
        }
        return instance ;
    }
}


接下來我解釋一下在併發時,雙重校驗鎖法會有怎樣的情景:

STEP 1. 執行緒A訪問getInstance()方法,因為單例還沒有例項化,所以進入了鎖定塊。

STEP 2. 執行緒B訪問getInstance()方法,因為單例還沒有例項化,得以訪問接下來程式碼塊,而接下來程式碼塊已經被執行緒1鎖定。

STEP 3. 執行緒A進入下一判斷,因為單例還沒有例項化,所以進行單例例項化,成功例項化後退出程式碼塊,解除鎖定。

STEP 4. 執行緒B進入接下來程式碼塊,鎖定執行緒,進入下一判斷,因為已經例項化,退出程式碼塊,解除鎖定。

STEP 5. 執行緒A獲取到了單例例項並返回,執行緒B沒有獲取到單例並返回Null。

理論上雙重校驗鎖法是執行緒安全的,並且,這種方法實現了lazyloading。

  1. 第七種終極版 (volatile) 對於6中Double-Check這種可能出現的問題(當然這種概率已經非常小了,但畢竟還是有的嘛~),解決方案是:只需要給instance的宣告加上volatile關鍵字即可,volatile版本如下:


public 
class 
Singleton
{

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

volatile關鍵字的一個作用是禁止指令重排,把instance宣告為volatile之後,對它的寫操作就會有一個記憶體屏障(什麼是記憶體屏障?),這樣,在它的賦值完成之前,就不用會呼叫讀操作。注意:volatile阻止的不singleton = newSingleton()這句話內部[1-2-3]的指令重排,而是保證了在一個寫操作([1-2-3])完成之前,不會呼叫讀操作(if (instance == null))。也就徹底防止了6中的問題發生。

  1. 使用ThreadLocal實現單例模式( 執行緒安全


public 
class 
Singleton 
{

    private static final ThreadLocal <Singleton > tlSingleton =
            new ThreadLocal <Singleton > ( ) {
               @Override
                protected Singleton initialValue ( ) {
                    return new Singleton ( ) ;
                }
            } ;
    /**
    * Get the focus finder for this thread.
    */

    public static Singleton getInstance ( ) {
        return tlSingleton . get ( ) ;
    }
    // enforce thread local access
    private Singleton ( ) { }
}

ThreadLocal會為每一個執行緒提供一個獨立的變數副本,從而隔離了多個執行緒對資料的訪問衝突。對於多執行緒資源共享的問題,同步機制採用了“以時間換空間”的方式,而ThreadLocal採用了“以空間換時間”的方式。前者僅提供一份變數,讓不同的執行緒排隊訪問,而後者為每一個執行緒都提供了一份變數,因此可以同時訪問而互不影響。

  1. 使用CAS鎖實現( 執行緒安全


/**

* 更加優美的Singleton, 執行緒安全的
*java學習交流:737251827  進入可領取學習資源及對十年開發經驗大佬提問,免費解答!
*/

public class Singleton {
/** 利用AtomicReference */
private static final AtomicReference <Singleton > INSTANCE = new AtomicReference <Singleton > ( ) ;
/**
 * 私有化
 */

private Singleton ( ) {
}
/**
 * 用CAS確保執行緒安全
 */

public static final Singleton getInstance ( ) {
  for ( ; ; ) {
  Singleton current = INSTANCE . get ( ) ;
            if ( current != null ) {
                return current ;
            }
           current = new Singleton ( ) ;
            if ( INSTANCE . compareAndSet ( null , current ) ) {
                return current ;
            }
        }
}

public static void main ( String [ ] args ) {
 Singleton singleton1 = Singleton . getInstance ( ) ;
 Singleton singleton2 = Singleton . getInstance ( ) ;
    System .out . println (singleton1 == singleton2 ) ;
}
}



來自 “ ITPUB部落格 ” ,連結:http://blog.itpub.net/70010294/viewspace-2844871/,如需轉載,請註明出處,否則將追究法律責任。

相關文章