单例模式(线程安全)

1、单例模式就是系统中对于某类只能有一个对象

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

       public class Singleton {
             private static Singleton instance= new Singleton()；   //直接初始化一个实例对象
             private Singleton() {}     //private 类型的构造函数，保证其它类对象不能直接new一个该对象的实例
             public static Singleton getInstance() {    //该类唯一一个public 方法
                    return instance;
             } 
        }

    上述代码中的一个缺点是：该类加载的时候就会直接new一个静态对象，当系统中这样的类较多时，会使得启动速度变慢。

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

       public class Singleton {
             private static Singleton instance； 
             private Singleton() {}     //private 类型的构造函数，保证其它类对象不能直接new一个该对象的实例
             public static synchronized Singleton getInstance() {    //对获取实例的方法进行同步
                    if (instance == null) {
                              instance = new Singleton();
                    }
                    return instance;
             } 
        }

     上述代码锁的粒度有点大

★ 方式三：(使用双重同步锁)

       public class Singleton {
             private static Singleton instance； 
             private Singleton() {}     //private 类型的构造函数，保证其它类对象不能直接new一个该对象的实例
             public static Singleton getInstance() {    //对获取实例的方法进行同步
                    if (instance == null) {
                            synchronized(Singleton.class) {
                                    if (instance == null) {
                                           instance = new Singleton();
                                    }
                            }
                    }
                    return instance;
             } 
        }

★ 方式四：(更好的是采用下面的方式，既不用加锁，也能实现懒加载)

       public class Singleton {         
             private Singleton() {}     //private 类型的构造函数，保证其它类对象不能直接new一个该对象的实例
             private static class Inner {             //采用内部类的方式
                     private static Singleton instance = new Singleton();
             }
             public static Singleton getInstance() {   
                    return Inner.instance;
             } 
        }