单例模式的五种实现方式以及避免反射和序列化带来的影响

单例模式（singleton）

1、通常，对象是通过操作属性来承担自己的职责，但如果某些类依赖该对象，我们需要找到该对象时，可以通过对该对象单例化，获取到唯一对象。如果无需找到，则该类对象无需单例，如System、Math等工具类。
2、单例模式是为了确保一个类有且仅有一个实例，且提供唯一的局部访问点
3、要求：线程安全、效率高、懒加载

饿汉式

1、私有化构造器
2、在该类下创建静态属性，类型为该类，并实例化
3、提供静态方法，返回该静态属性

public class SingletonDemo1 {
	
	//类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
	private static SingletonDemo1 instance = new SingletonDemo1();
	
	private SingletonDemo1(){
	}
	
	//方法没有同步，调用效率高！
	public static SingletonDemo1  getInstance(){
		return instance;
	}
	
}

懒汉式

1、私有化构造器
2、在该类下创建静态属性，类型为该类，不初始化
3、提供同步静态方法，若对象为null，则初始化。返回该静态属性

public class SingletonDemo2 {
	
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo2 instance;  
	
	private SingletonDemo2(){ //私有化构造器
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo2  getInstance(){
		if(instance==null){
			instance = new SingletonDemo2();
		}
		return instance;
	}
	
}

双重检测锁式

懒汉式的优化，由于编译器优化和JVM底层原因，偶尔会出现问题。
具体原因见：https://www.cnblogs.com/xz816111/p/8470048.html

public class SingletonDemo3 { 

  private static SingletonDemo3 instance = null; 

  public static SingletonDemo3 getInstance() { 
    if (instance == null) { 
      SingletonDemo3 sc; 
      synchronized (SingletonDemo3.class) { 
        sc = instance; 
        if (sc == null) { 
          synchronized (SingletonDemo3.class) { 
            if(sc == null) { 
              sc = new SingletonDemo3(); 
            } 
          } 
          instance = sc; 
        } 
      } 
    } 
    return instance; 
  } 

静态内部类式

饿汉式的优化

public class SingletonDemo4 {
	
	private static class SingletonClassInstance {
		private static final SingletonDemo4 instance = new SingletonDemo4();
	}
	
	private SingletonDemo4(){
	}
	
	//方法没有同步，调用效率高！
	public static SingletonDemo4  getInstance(){
		return SingletonClassInstance.instance;
	}
	
}

枚举式

public enum SingletonDemo5 {
	
	//这个枚举元素，本身就是单例对象！
	INSTANCE;
	
	
	//添加自己需要的操作！
	public void singletonOperation(){
	}
	
}

避免反序列化与反射创建新对象

public class SingletonDemo6 implements Serializable {
	//类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
	private static SingletonDemo6 instance;  
	
	private SingletonDemo6(){ //私有化构造器
		if(instance!=null){
			throw new RuntimeException();//抛出异常，反射创建已存在的对象会失败
		}
	}
	
	//方法同步，调用效率低！
	public static  synchronized SingletonDemo6  getInstance(){
		if(instance==null){
			instance = new SingletonDemo6();
		}
		return instance;
	}
	
	//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
	private Object readResolve() throws ObjectStreamException {
		return instance;
	}
	
}