5.單例模式

首先單例模式中的懶漢和餓漢模式，

懶漢模式：

//懶漢式單例類.在第一次呼叫的時候例項化自己

public class Singleton {

   private Singleton() {}

   private static Singleton single=null;

   //靜態工廠方法

   public static Singleton getInstance() {

        if (single == null) { 

            single = new Singleton();

        } 

       return single;

    }

}

但是這個懶漢模式並沒有考慮到執行緒安全，所以可以有三種方法對這個懶漢模式進行執行緒安全化

1.給getInstance方法加synchronized關鍵字

2.雙重檢查鎖定

public static Singleton getInstance() {

       if (singleton == null) { 

           synchronized (Singleton.class) { 

               if (singleton == null) { 

                  singleton = new Singleton();

               } 

           } 

       } 

       return singleton;

    }

3.靜態內部類的方式

public class Singleton { 

   private static class LazyHolder { 

      private static final Singleton INSTANCE = new Singleton(); 

   } 

   private Singleton (){} 

   public static final Singleton getInstance() { 

      return LazyHolder.INSTANCE; 

   } 

} 

餓漢模式：

//餓漢式單例類.在類初始化時，已經自行例項化

public class Singleton1 {

   private Singleton1() {}

   private static final Singleton1 single = new Singleton1();

   //靜態工廠方法

   public static Singleton1 getInstance() {

       return single;

    }

}

區別：

餓漢模式天生就是執行緒安全的，而懶漢模式則需要自行實現執行緒安全

餓漢式模式在類建立的時候就會例項化一個靜態的物件出來，會佔用一定記憶體，但是相應的第一次呼叫會快一點

懶漢模式的延遲載入，需要呼叫的時候才會例項化物件

第一種方法實現同步的話，每次呼叫都會同步，非常耗效能，因為大部分情況是不需要同步的

第二種方法雙重判斷則避免了每次都需要同步的情況

第三種方法，利用了ClassLoader的機制確保初始化Intance的時候都只有一個執行緒

spring中的單例模式：

spring中的依賴注入都發生在AbstractBeanFactory的getBean方法裡面，而getBean方法裡面doGetBean方法中的getSingleton方法

protected Object getSingleton(String beanName, boolean allowEarlyReference)

    {

        Object singletonObject = singletonObjects.get(beanName);

        if(singletonObject == null &&isSingletonCurrentlyInCreation(beanName))

            synchronized(singletonObjects)

            {

                singletonObject = earlySingletonObjects.get(beanName);

                if(singletonObject == null && allowEarlyReference)

                {

                    ObjectFactory singletonFactory =(ObjectFactory)singletonFactories.get(beanName);

                    if(singletonFactory != null)

                    {

                        singletonObject = singletonFactory.getObject();

                        earlySingletonObjects.put(beanName, singletonObject);

                        singletonFactories.remove(beanName);

                    }

                }

            }

        return singletonObject == NULL_OBJECT ? null : singletonObject;

   }

可以看到spring中用的是懶漢模式的雙重判斷來實現執行緒安全的，避免在加鎖的瞬間有其他注入的時候建立例項