單例模式的多線程

單例模式的原理：保證一個類有一個實例，并且提供一個全局的訪問點（內存地址唯一）

實現方式：

1、飽漢模式：

  1: publicclass Singleton{

  2:   

  3:    privatestatic Singleton s = null;

  4: 

  5:    private Singleton(){

  6: 

  7:    }

  8: 

  9:    publicstatic Singleton getInstance(){

 10:      

 11:       if(s ==null){

 12:         s = new Singleton();

 13:       }

 14:      return s;

 15:    }

 16: }

2、餓漢模式

  1: publicclass Singleton{

  2:   privatestatic Singleton s = new Singleton();

  3:   private Sinleton(){}

  4:   publicstatic Singleton getInstance(){

  5:    return s;

  6:    }

  7: }

單例模式的線程安全問題：

    1、通過synchronized關鍵字來實現

  1: publicclass Single

  2: {

  3:   privatestatic Single single ;

  4:   private Single(){

  5:   }

  6:   publicstaticsynchronized Single getInstance(){

  7:     if(single == null){

  8:       single = new Single();

  9:     }

 10:     return single;

 11:   }

 12: }

這樣的話可以強制在程序運行過程中只有一個線程調用該方法獲得該類的一個實例，但是缺點也是如此：只有在第一次使用該對象時需要同步，再次

獲取該對象時就不需要再同步了，這時候的同步就變的多余了。

2、其實餓漢模式就是改善多線程的一種有效手段，這樣JVM保證任何線程訪問單例對象時，一定先創建該實例，代碼同上

3、另外一種改善多線程的方式

  1: publicclass Singleton { 

  2: 

  3:     privatevolatilestatic Singleton uniqueInstance;

  4:  

  5:     private Singleton() {}

  6:         

  7:     publicstatic Singleton getInstance() { 

  8:   if(uniqueInstance == null) { //(1)

  9:         //只有第一次才徹底執行這里的代碼

 10:      synchronized() {

 11:         //再檢查一次

 12:         if(uniqueInstance == null)

 13:     uniqueInstance = new Singleton();

 14:         }

 15:   }

 16:          return uniqueInstance;

 17:     }

 18: }

在最開始如果有1、2、3個線程走到了(1)處，假設1進入了同步塊，2、3等待。1實例化后，2進入同步塊，發現uniqueInstance已經不為空，跳出同步塊。接著3進入，又跳出同步塊。

   volatile關鍵字確保：當uniqueInstance變量被初始化成Singleton實例時，多個線程正確地uniqueInstance變量。如果性能是你關心的重點，那么這個做法可以幫你大大地減少getInstance()的時間耗費。