1梦裂、單例模式就是系統(tǒng)中對于某類只能有一個對象

★ 方式一：(不使用同步鎖)

       public class Singleton {
             private static Singleton instance= new Singleton()忆畅；   //直接初始化一個實例對象
             private Singleton() {}     //private 類型的構造函數(shù)夹姥，保證其它類對象不能直接new一個該對象的實例
             public static Singleton getInstance() {    //該類唯一一個public 方法
                    return instance;
             } 
        }

    上述代碼中的一個缺點是：該類加載的時候就會直接new一個靜態(tài)對象滋迈，當系統(tǒng)中這樣的類較多時，會使得啟動速度變慢。

★ 方式二：(使用同步鎖)

       public class Singleton {
             private static Singleton instance； 
             private Singleton() {}     //private 類型的構造函數(shù)休蟹，保證其它類對象不能直接new一個該對象的實例
             public static synchronized Singleton getInstance() {    //對獲取實例的方法進行同步
                    if (instance == null) {
                              instance = new Singleton();
                    }
                    return instance;
             } 
        }

     上述代碼鎖的粒度有點大

★ 方式三：(使用雙重同步鎖)

       public class Singleton {
             private static Singleton instance； 
             private Singleton() {}     //private 類型的構造函數(shù)日矫，保證其它類對象不能直接new一個該對象的實例
             public static Singleton getInstance() {    //對獲取實例的方法進行同步
                    if (instance == null) {
                            synchronized(Singleton.class) {
                                    if (instance == null) {
                                           instance = new Singleton();
                                    }
                            }
                    }
                    return instance;
             } 
        }

★ 方式四：(更好的是采用下面的方式赂弓，既不用加鎖，也能實現(xiàn)懶加載)

       public class Singleton {         
             private Singleton() {}     //private 類型的構造函數(shù)哪轿，保證其它類對象不能直接new一個該對象的實例
             private static class Inner {             //采用內(nèi)部類的方式
                     private static Singleton instance = new Singleton();
             }
             public static Singleton getInstance() {   
                    return Inner.instance;
             } 
        }