Java设计模式——单例模式

#Java单例模式

单例模式注意事项和细节说明

1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使
   用单例模式可以提高系统性能
2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
3. 单例模式 使用的场景：需要 频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级
   对象)，但又经常用到的对象、 工具类对象、频繁访问数据库或文件的对象(比如 数据源、session 工厂等)
   原文链接：https://blog.csdn.net/fd2025/article/details/79711198

一、饿汉式

类加载就会导致该单例实例对象被创建

（1）静态成员变量

/**
 * 饿汉式单例模式 （静态成员变量）
 */
public class HungrySingLetonDemo1 {
    //私有构造方法
    private HungrySingLetonDemo1(){};
    private static HungrySingLetonDemo1 instance=new HungrySingLetonDemo1();
    public static HungrySingLetonDemo1 getInstance(){
        return instance;
    }
}

（2）饿汉式静态代码块

/**
 * 饿汉式单例模式（静态代码块）
 */
public class HungrySingLetonDemo2 {

    //私有化构造方法
    private HungrySingLetonDemo2(){}
    private static HungrySingLetonDemo2 instance;
    static {
        instance=new HungrySingLetonDemo2();
    }
    //获取类对象
    public static HungrySingLetonDemo2 getInstance(){
        return instance;
    }
}

二、懒汉式

类加载不会导致该单例实例对象被创建，而是首次使用该对象时才会创建

（1）线程安全的懒汉式

/**
 * 懒汉式（线程安全的）
 */
public class LazySingLetonDemo1 {
    private LazySingLetonDemo1(){}
    private static LazySingLetonDemo1 instance;
    public static synchronized LazySingLetonDemo1 getInstance(){
        if (null==instance){//如果没有syn锁，在多线程下这边可能会创建多个对象
            instance =new LazySingLetonDemo1();
        }
        return instance;
    }
}

（2）双重检查锁模式

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题；但是多线程情况下，可能会出现空指针问题，出现问题的原因式JVM在实例化对象的时候会进行优化和指令重排序操作。要解决这个问题，只需要使用 volatile 关键字，volatile关键字可以保证可见性和有序性

/**
 * 懒汉式（双重检查锁模式）
 */
public class LazySingLetonDemo2 {
    private LazySingLetonDemo2(){}
    private static LazySingLetonDemo2 instance;
    public static volatile LazySingLetonDemo2 getInstance(){
        if (null==instance){
            synchronized (LazySingLetonDemo2.class){
                if (null==instance){
                    instance=new LazySingLetonDemo2();
                }
            }
        }
        return instance;
    }
}

（3）静态内部类

/**
 * 懒汉式（静态内部类）
 */
public class LazySingLetonDemo3 {
    private static boolean flag=false;
    private LazySingLetonDemo3(){
        //解决反射破坏单列
        synchronized (LazySingLetonDemo3.class){
            if (flag){
                throw new RuntimeException("不能创建多个对象");
            }
            flag=true;
        }
    }
    private static class LazySingLetonHolder{
        private static final LazySingLetonDemo3 INSTANCE = new LazySingLetonDemo3();
    }
    public static LazySingLetonDemo3 getInstance(){
        return LazySingLetonHolder.INSTANCE;
    }
    //当进行反序列化时，会自动调用该方法，将该方法的返回值返回
    public Object readResolve(){
        return LazySingLetonHolder.INSTANCE;
    }
}

破环单例模式 当序列化反序列化或者使用反射时会被破坏
解决方案： 序列化 在类中添加 readResolve()方法;
反射 在私有构造方法中加判断

总结

实现方式主要是私有化构造方法；饿汉式与懒汉式区别于饿汉式在类加载的时候对象已经创建，懒汉式在调用方法时才创建