单例模式

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例                  
　　1、单例类只能有一个实例。
　　2、单例类必须自己自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。

    单例所具备的特点：

•     私有化的构造函数
•     私有的静态的全局变量
•     公有的静态的方法

饿汉式单例：在单例类被加载时候，就实例化一个对象交给自己的引用；

懒汉式单例：在调用取得实例方法的时候才会实例化对象。

饿汉式单例模式

public class Test3 {
	/**
	 * 饿汉式单例模式（线程安全）
	 */
	private static Test3 test3 = new Test3();
	private Test3(){
		
	}
	public static Test3 getInstance(){
		return test3;
	}
}

优点：线程安全。因为它在类加载的时候就初始化了对象

缺点：类加载时初始化。如果程序从头到位都没用使用这个单例的话，单例的对象还是会创建。这就造成了不必要的资源浪费。

懒汉式单例模式

    /**
	 * 懒汉式（线程安全）
	 */
	private static Test3 test3 = null;
	private Test3(){
		
	}
	public synchronized static Test3 getInstance(){
		if(test3 == null) {
			test3 = new Test3();
		}
		return test3;
	}

优点：第一次调用才初始化，避免内存浪费。

缺点：加锁，执行效率不高

双层校验锁

private static Test3 test3 = null;
	private Test3(){
		
	}
	public static Test3 getInstance(){
		if(test3 == null){
			synchronized (Test3.class) {
				if(test3 == null){
					test3 = new Test3();
				}
			}
		}
		return test3;
	}

在获取单例对象的时候，我们先进行了两为空判断，并且在第二次判断前加了锁。

为什么要用两个判空呢？

如果没有第二个判空的，假如第一个线程判断test3 == null,进入拿到锁。再进入第二个判断条件内，创建 一个Test3对象。在这个中途中，另外一个线程进入第一个判断条件内等待锁对象的释放，第一个创建完成之后，第二个就会拿到锁对象，如果没有第二次判空的话，就会再次创建一个对象，这样就不能保证为单例了。

DCL（双层校验锁）模式失效：
test3 = new Test3();这句话执行的时候，会进行下列三个过程：

1. 分配内存。
2. 初始化构造函数和成员变量。
3. 将对象指向分配的空间。

由于JMM(Java Memory Model)的规定，可能会出现1-2-3和1-3-2两种情况。（指令重排序）
所以，就会出现线程A进行到1-3时，就被线程B取走，B发现test3不为null时返回test3 但是此时的test3还没有被初始化成功。所以就出现了错误。这个时候DCL模式就失效了。

由于这个原因我们可以采用Java中的volatile关键字。（volatile——>https://blog.csdn.net/qq_37937537/article/details/82764667）

volatile可以有效防止重排序 ，可以保证代码的有序性。

private static volatile Test3 test3 = null;
	private Test3(){
		
	}
	public static Test3 getInstance(){
		if(test3 == null){
			synchronized (Test3.class) {
				if(test3 == null){
					test3 = new Test3();
				}
			}
		}
		return test3;
	}

静态内部类

       private static class SingletonHolder {  
		    private static final Test3 test3 = new Test3();  
	   }  
	   private Test3 (){}  
	   public static Test1 getInstance() {  
		   return SingletonHolder.test3;  
	   }  

可以发现这种方式，并未加锁，因为第一次加载Test3 类时，并不会实例化单例对象，只有第一次调用getInstance()方法时会导致虚拟机加载SingletonHolder类，这方式不仅能保证对象的单一性，还避免加锁带来的性能问题，又启动了延迟加载的优化。

反射和反序列化方式会破坏单例模式，我们应该怎样解决？

1，这些模式在实现了Serializable接口后，反序列化时单例会被破坏。当从IO流中读取对象时readResolve()方法都会被调用到，实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象。所以要重写readResolve()方法。

private Object readResolve() throws ObjectStreamException {
        return test3;
    }

2，反射是通过class对象，来调用构造器创建新的对象。那么我们只需要在它调用构造器的时候手动抛出异常即可。

private static Test3 test3 = null;
	private static boolean flag = false;
	private Test3(){
		/**
		 * 反射就是通过它的Class对象来调用构造器创建出新的对象
		 * 我们只需要在构造器中手动抛出异常，导致程序停止就可以达到目的了
		 */
	       if(flag == false)  
             {  
                  flag = !flag;  
              }  
             else 
             {  
                 throw new RuntimeException("单例模式被侵犯！");  
             }  
	}
	public synchronized static Test3 getInstance(){
		if(test3 == null) {
			test3 = new Test3();
		}
		return test3;
	}
}

枚举模式

一个可以直接避免反射，序列化攻击的实现单例模式的方式。

public enum Singleton{
    singleton;
    public void hello(){
        System.out.print("hello");
    }
}