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 
可见该方法是通过调用构造方法创建出一个新的对象。
（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(){returnInstance;}}
2、静态代码块机制
public class HungryStaticSingleton {// 静态志方式饿汉式单例private static final HungryStaticSingleton hungrySingleton ;static {hungrySingleton = new HungryStaticSingleton();} /** * 私有构造 */private HungryStaticSingleton() {}//取实例方法public static HungryStaticSingleton getInstance() {return hungrySingleton;}}
3、枚举类实现饿汉：枚举类实现方式不会被反射和反序列化破环单例
public enumTest_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底层逻辑，完美避免了线程安全问题，