java设计模式-单例模式

单例模式：饿汉模式以及懒模式

饿汉模式：线程安全，不会产生多个实例。但如果加载耗时，增加项目初始化时间，如果在运行过程中，没有用到，可能增加空间的浪费

懒汉模式：充分利用资源，实现懒加载策略。（可能线程不安全，需要用户自己优化）

例子

饿汉模式

/** * Description:饿汉模式 * User: lc * Date: 2017/9/30 0030 * Time: 下午 3:52 */public class HungrySingleton {    /**     * 利用classLoader加载     */    private static final HungrySingleton hungrySingleton = new HungrySingleton();    /**     * 私有的构造函数：不让外界创建     */    private HungrySingleton() {    }//提供唯一对外，反射除外    public static HungrySingleton getInstance() {        return hungrySingleton;    }}

懒汉模式：几种变形

1.不加任何修饰（不安全）

/** * Description:懒汉模式 * User: lc * Date: 2017/9/30 0030 * Time: 下午 3:58 */public class LazySingleton {    /**     * 未初始化     */    private static LazySingleton instance;    private LazySingleton() {    }    public static LazySingleton getInstance() {        //第一次调用会初始化.不过多线程情况下，会重复初始化（线程安全问题）        if (instance == null) instance = new LazySingleton();        return instance;    }}

2.加synchronized（不安全）

/** * Description:懒汉模式 * User: lc * Date: 2017/9/30 0030 * Time: 下午 3:58 */public class LazySingleton1 {    /**     * 未初始化     */    private static LazySingleton1 instance;    private LazySingleton1() {    }    public static LazySingleton1 getInstance() {        if (instance == null) {            //但是如果线程A和B同时执行到了Synchronized(singleton.class)，            // 虽然也是只有一个线程能够执行，假如线程B先执行，线程B获得锁，线程B执行完之后，线程A获得锁，            // 但是此时没有检查singleton是否为空就直接执行了，所以还会出现两个singleton实例的情况            synchronized(LazySingleton1.class)            {                instance = new LazySingleton1();            }        }        return instance;    }}

2.加synchronized以及判断是否NULL（不安全）

/** * Description:懒汉模式:双重检查 * User: lc * Date: 2017/9/30 0030 * Time: 下午 3:58 */public class LazySingleton2 {    /**     * 要volatile修饰     * 理由：比如2个线程A/B线程。     */    private  static LazySingleton2 instance;    private LazySingleton2() {    }    public static LazySingleton2 getInstance() {        if (instance == null) {            synchronized (LazySingleton2.class) {                if(instance == null)                    //此处还是有问题：虽然做了双重判断。 因为 newLazySingleTon1()是非原子操作                    //  A a=new A()                    //  进行了三步操作：1.申请空间2.将引用指向该空间地址3.初始化构造                    //在理想情况下，按照1->3->2的步骤执行时，双检锁形式可以正常工作，但是由于Java内存模型，允许重排序，所以                    //完全可能按照1->2->3的顺序执行，则导致双检锁形式出现问题。即线程1在执行single=new Singleton()语句时，刚好按照1->2->3的顺序                     //执行到step2处，此时，instance指向mem内存区域，而该内存区域未被初始化；同时，线程2在第一个if(instance==null)地方发现instan                     // ce不为null了，于是得到这个为被初始化的实例instance进行使用，导致错误。
                    //synchronized:允许修饰的对象，可见性，但是可以允许jvm的进行重排序                    instance = new LazySingleton2();                return instance;            }        }        return instance;    }}


3.加synchronized以及volatile(安全)
/** * Description:懒汉模式:双重检查 * User: lc * Date: 2017/9/30 0030 * Time: 下午 3:58 */public class LazySingleton2 {    /**     * 要volatile修饰     * 理由：比如2个线程A/B线程。     */    private volatile static LazySingleton2 instance;    private LazySingleton2() {    }    public static LazySingleton2 getInstance() {        if (instance == null) {            synchronized (LazySingleton2.class) {                if (instance == null)                    instance = new LazySingleton2();            }        }        return instance;    }}



4.静态内部类(安全)
/** * Description:懒汉模式: * User: lc * Date: 2017/9/30 0030 * Time: 下午 3:58 */public class StaticLazySingleton {    /**     *     *1.私有内部类，外部不知道该类的存在     * 2.外部类初始化的时候，该内部类还没加载，只有通过第一次调用才（比如这个例子：触发getInstance()）加载，加载是利用jvm加载，而jvm加载某个类，只能加载一次，所以是只能有一个class类。故线程安全     * 3.对外提供唯一的出口     *     */    private StaticLazySingleton() {    }   // 静态内部类    private static class StaticLazySingletonInstance    {        private static final StaticLazySingleton staticLazySingleton = new StaticLazySingleton();    }    public static StaticLazySingleton getInstance() {        return StaticLazySingletonInstance.staticLazySingleton;    }}