单例模式详解

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式的构造器是私有的。

饿汉式单例
这种单例模式的好处是没哟线程安全问题，坏处是开始就初始化会造成空间的浪费。

public class Hungry{
	// private byte[] data = new byte[1024 * 1024];
	private final static Hungry hungry = new Hungry();
	
	private Hungry(){
	
	}
	
	public static Hungry getInstance(){
		return hungry;
	}
}

懒汉式单例
懒汉式就是实例在用到的时候才去创建，用的时候才检测有没有实例，没有则创建，有则返回。这样有多个线程是就会产生线程安全问题。

public class Lazy{
	private static Lazy instance;

	private Lazy(){
		
	}
	
	public static Lazy getInstance(){
		if(instance == null){
			instance = new Lazy();
		}
		return instance;
	}
}

上边这种写法显然是存在线程安全的问题的，当多个线程同时需要这个实例的时候，很可能就会创建多个实例出来，就违反了单例的原则。为了解决这种情况，给这个类加锁。使用双重锁的原因是，如果t1线程判断instance为空，这是它的时间片刚好用完，这是t2线程判断为null，并创建了instance，这时t1得到cpu时间片，他会继续执行下去，他还是会认为instance为null，再次创建instance，这样就会造成多次创建单例对象。所以要是用双锁来判断。

public class Lazy{
	private static Lazy instance;

	private Lazy(){

	}

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

但是到这一步单例模式仍然是有问题的，这里涉及到类加载的问题 instance = new Lazy(); 这一步并不是一个原子性的操作，一个类的装载过程有 加载 链接 初始化 三步
加载：将字节码文件读入JVM，生成Class类
链接：1、验证 确保被加载的类的正确性 2、准备 为类的静态变量分配内存并赋予默认值 3、解析 将常量池中的符号引用替换为直接引用（符号引用就是一组符号来描述目标，可以是任何字面量，直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄）
初始化：为静态变量赋初值
由此可以看出类的装载并不是原子性的操作，而在jvm执行指令时，为了优化很可能执行指令的顺序会发生改变，这样就会导致问题的发生。如果一个线程创建该类的时候先将指针指向了某一块地址，后将这这个类初始化，这个时候另外一个线程调用单例发现该单例已经存在，就会直接调用但是这个实例并没有进行初始化，就会出错。因此为了避免这种错误的发生就要将lazy变量用volitile来进行修饰。volatitle的作用：保证变量的可见性，不保证原子性，防止jvm指令重排。

public class Lazy{
	private volatitle static Lazy instance;

	private Lazy(){
	
	}

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

到了这一步本来懒汉式单例就算是结束了，但是由于反射的存在，使得单例模式又变得不安全。

public class Lazy{
	private volatitle static Lazy instance;

	private Lazy(){
	
	}

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

	public static void main(String[] args){
		Lazy instance = Lazy.getInstance();
		通过反射机制创建单例
		获取Lazy的无参构造器
		Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor();
		由于是私有方法，安全检测关闭
		declaredConstructor.setAccessible(true);
		Lazy instance2 = declaredConstructor.newInstance();
		System.out.println(instance.hashCode());
		System.out.println(instance2.hashCode());
		经过结果输出比较，显然instance和instance2并不是同一个实例，由此可见反射又破坏了单例
	}

}

内部类实现单例模式

public class Lazy{
	//私有构造方法
	private Lazy(){
	}
	//对外提供访问方法
	public static Lazy getInstace(){
		return Singleton.INSTACE;
	}
	//内部类
	private static class Singleton{
		private static final Singleton INSTANCE = new Lazy()
;	}

}

虽然可以进一步通过在构造其中加锁，或者标志位来进行改进，但是始终都会有办法破坏单例，为了解决反射对单例的破坏，最终使用枚举类来解决。因为枚举类没有无参构造方法，只有有参构造方法。在有参构造方法中有一句
if ((clazz.getModifiers() & Modifier.ENUM) != 0) 这句代码表明如果这个类是枚举类就抛出异常。因此反射不能通过构造器对枚举类进行构造，也就无法破坏枚举类了。

public enum EnumSingle{
	INSTANCE;

	public EnumSingle {
		return INSTANCE;
	}
}