24种设计模式之单例模式（饿汉式、懒汉式）

一、单例模式

单例模式( Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如,总统，班主任等。J2EE标准中的ServletContext 、ServletContextConfig 等、spring框架应用中的。

• 特点：构造方法私有，提供一个全局访问点。

• 实现方式：有很多，1.饿汉式 2.懒汉式 3.注册式 4.ThreadLocal

• 优点：内存中只有一个实例，减少内存开销；避免对资源多重占用；设置全局访问点，严格控制访问。

• 缺点：没有接口，扩展困难；如果要扩展单例对象，只有修改代码，没有其他途径，不符合程序的开闭原则。

二、饿汉式单例模式

饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没出现以前就实例化了，不可能存在访问安全问题。

总结：

final：防止反射破坏单例。

饿汉式缺点：可能会造成内存空间的浪费。

饿汉式单例模式适用于单例对象较少的情况。这样写可以保证绝对线程安全、执行效率比较高。但是它的缺点也很明显，就是所有对象类加载的时候就实例化。这样一来,如果系统中有大批量的单例对象存在，那系统初始化是就会导致大量的内存浪费。

饿汉式之单例实现方式

1、标准饿汉模式

通过私有构造器，防止外部进行实例创建；通过属性在类加载时实例化对象，提供全局访问方法取得实例。利用代码的执行先后顺序，在线程还没有出现前就完成了实例化。

public class HungrySingleton {    // 静态实例代码段，饿汉实现类加载初始化时调用构造方法    private static final HungrySingleton hungrySingleton = new HungrySingleton();         // 私有方法防止外部调用创建对象    private HungrySingleton() {}    // 外部类获得单例对象方法    public static HungrySingleton getInstance() {        return hungrySingleton;    }}

该单例实现方式可以被反序列化和反射破坏：

（1）反射破坏方式如下：该方式可以通过构造方法创建出一个全新的实例对象。

public static void reflect() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {        System.out.println(Test.getInstance());        //反射破坏        //得到类        Class c = Test.class;        Constructor constructor = c.getDeclaredConstructor();        //设置私有可调用        constructor.setAccessible(true);        // 打印创建的实例对象        System.out.println(constructor.newInstance());    }

可见该方法是通过调用构造方法创建出一个新的对象。

（2）反序列化破坏单例方式如下：

public static void ser() throws IOException, ClassNotFoundException {        //反序列化        ByteArrayOutputStream outputStream=new ByteArrayOutputStream();        ObjectOutputStream objectOutputStream=new ObjectOutputStream(outputStream);        //将类转化        objectOutputStream.writeObject(Test.getInstance());        System.out.println(Test.getInstance());        ObjectInputStream objectInputStream=new ObjectInputStream(new ByteArrayInputStream(outputStream.toByteArray()));        //读出类，变为一个新的类        Test test= (Test) objectInputStream.readObject();        System.out.println(test);    }

该方式可以看出反序列化构造出的对象并不是通过构造方法。

由此针对上面两种破坏方式做出优化得到以下的代码：

public class Test implements Serializable {    //静态实例代码段，饿汉实现类加载初始化时调用构造方法    private static Test Instance=new Test();    //私有方法防止外部调用创建对象    private Test(){        if(Instance!=null)// 此处方式反射调用破环单例对象，抛出异常            throw new RuntimeException("单例模式不能创建");        System.out.println("构造方法");    }    //外部类获得单例对象方法    public static Test getInstance(){        return Instance;    }    //其他方法    public static void otherMethod(){        System.out.println("other");    }    //防止反序列化破坏单例    public Object readResolve(){        return  Instance;    }}

2、静态代码块机制

public class HungryStaticSingleton {    // 静态志方式饿汉式单例    private static final HungryStaticSingleton hungrySingleton ;    static {        hungrySingleton = new HungryStaticSingleton();    }             private HungryStaticSingleton() {}    //取实例方法    public static HungryStaticSingleton getInstance() {        return hungrySingleton;    }}

3、枚举类实现饿汉：枚举类实现方式不会被反射和反序列化破环单例

public enum  Test_1 {    Instance;    //枚举类默认构造方法私有    Test_1(){        System.out.println("构造方法");    }    //获取对象    public static Test_1 getInstance(){        return Instance;    }    //其他方法    public static void otherMethod(){        System.out.println("other");    }}

三、懒汉式单例模式

懒汉式类被加载的时候，没有立刻被实例化，第一次调用getInstance的时候，才真正的实例化。

如果要是代码一整场都没有调用getInstance，此时实例化的过程也就被省略掉了，又称“延时加载”

一般认为“懒汉模式” 比 “饿汉模式”效率更高。

懒汉模式有很大的可能是“实例用不到”，此时就节省了实例化的开销。

懒汉式之单例实现方式

1、普通的懒汉式

public class LazySingleton {    private LazySingleton() {    }    private volatile static LazySingleton instance;    //加入了同步代码，解决线程不安全问题    public synchronized static LazySingleton getInstance() {        if (instance == null) {            instance = new LazySingleton();        }        return instance;    }}

这种设计明显的一个问题就是执行效率低，无论是否已经存在实例，在多线程的情况下都会发生阻塞。

对以上代码进行改进，首先让当程序中实例存在的时候，直接返回实例，不需要抢占锁。当程序中不存在实例时，再抢占锁进行创建。根据以上的思想，出现了第二种懒汉式方式:

2、双重检查锁DCL(Double Check Lock双端检锁)

public class LazyDoubleCheckSingleton {    private LazyDoubleCheckSingleton() {    }    private volatile static LazyDoubleCheckSingleton instance;    public static LazyDoubleCheckSingleton getInstance() {        //确定是否需要阻塞        if (instance == null) {            // 线程安全：双重检查锁（同步代码块）            synchronized (LazyDoubleCheckSingleton.class) {                //确定是否需要创建实例                if (instance == null) {                    //这里在多线程的情况下会出现指令重排的问题，所以对共有资源instance使用关键字volatile修饰                    instance = new LazyDoubleCheckSingleton();                }            }        }        return instance;    }}

对于第二种方式，较第一种方式而言，性能提高了，但是代码的可读性差了。

---

DCL(Double Check Lock双端检锁)机制不一定线程安全，原因是有指令重排序的存在，加入volatile可以禁止指令重排。

原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。

instance = new LazyDoubleCheckSingleton();可以分为以下3步完成（伪代码）

memory = allocate(); // 1.分配对象内存空间

instance(memory); // 2.初始化对象

instance=memory； // 3.设置instance指向刚分配的内存地址，此时instance != null

步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。

memory = allocate(); // 1.分配对象内存空间

instance=memory； // 3.设置instance指向刚分配的内存地址，此时instance != null，但是对象还没有初始化完成

instance(memory); // 2.初始化对象

但是指令重排只会保证串行语义的执行的一致性（单线程），但并不会关心多线程间的语义一致性。

所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。

3、静态内部类

 public class LazyInnerClassSingleton {    //虽然构造方法私有了，但是逃不过反射的法眼    private LazyInnerClassSingleton(){};     // 懒汉式单例    // LazyHoler里面的逻辑需等外部方法调用时候才执行    // 巧妙运用了内部类的特性    // JVM底层逻辑，完美避免了线程安全问题    public static final LazyInnerClassSingleton getInstance(){        return LazyHoler.LAZY;    }     public static class LazyHoler{        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();    }}

为防止调用者反射破坏，可以这么写：

public class LazyInnerClassSingleton {    //虽然构造方法私有了，但是逃不过反射的法眼    private LazyInnerClassSingleton(){        // 防止调用者反射攻击;         if(LazyHoler.LAZY != null){            throw new RuntimeException("禁止创建多个实例！"); // 其他写法也可加上        }    };     // 懒汉式单例    // LazyHoler里面的逻辑需等外部方法调用时候才执行    // 巧妙运用了内部类的特性    // JVM底层逻辑，完美避免了线程安全问题    public static final LazyInnerClassSingleton getInstance(){        return LazyHoler.LAZY;    }     public static class LazyHoler{        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();    }}

分析：静态内部类相对来说更优，LazyHoler里面的逻辑需等外部方法调用时候才执行，所以也属于懒汉式，巧妙运用了内部类的特性，JVM底层逻辑，完美避免了线程安全问题，

来源地址：https://blog.csdn.net/inexaustible/article/details/128816512