在整个程序中，保持只有一个实例对象，就是单例模式。
单例模式可以减少构建，GC的次数，提升性能，还能减少堆内存的开销。
1. 懒汉式
在需要使用对象的时候，才进行创建
通过private构造方法，确保外部不能new出对象，通过一个静态方法进行对象获取。
public class LazySingleton implements Serializable {
private static LazySingleton lazySingleton = null;
private LazySingleton() {
}
public static LazySingleton getInstance(){
if(lazySingleton == null){
lazySingleton = new LazySingleton();
}
return lazySingleton;
}
}需要注意的是，懒汉式是线程不安全的，并发情况下有线程安全问题，需要进行同步处理。
可以在getInstance()方法上加上synchronized。但是锁的粒度很大，所以引出了双重检查锁
2. 双重检查锁
- 通过两个if判断,加上同步锁进行实现
- 只进行一次判断上锁的话，上锁解锁后，单例对象就被重置了，因为有可能多个线程同时都通过了第一次判断，只是没抢到锁
- 而且，需要加上volatile保证可见性和同步性，因为锁住的是class对象，不是单例对象，所以JMM保证的unlock刷到主存，lock读到工作内存只对class对象起作用，单例对象的可见性无法保证，同样的，是class对象的unlock操作在lock操作之前，happens before原则也无法保证有序性，因为整个临界区内根本找不到一个和class对象相关的操作。
public class DoubleCheckSingleton {
private static volatile DoubleCheckSingleton doubleCheckSingleton ;
private DoubleCheckSingleton(){
}
public static DoubleCheckSingleton getInstance(){
if(doubleCheckSingleton ==null){
synchronized (DoubleCheckSingleton.class){
if (doubleCheckSingleton == null){
doubleCheckSingleton = new DoubleCheckSingleton();
}
}
}
return doubleCheckSingleton;
}
}3. 静态内部类
双重检查锁对于同步控制特别的复杂繁琐，有没有什么底层已经进行了的同步操作可以利用的呢？
答案是类加载的loadclass是被synchronized修饰的，类的加载是同步的，类加载进行到初始化部分的时候会对静态变量赋初始值，也会执行静态代码块。
在单例类中,通过私有的静态内部类,创建单例对象
静态内部类只有在被调用的时候才会被加载，实现了懒加载。
public class StaticInnerClassSingleton {
/**
* 第一次被调用到的时候才会进行类加载，进行初始化（JVM相关知识，加载、连接（验证，准备，解析）、初始化（为静态变量赋值）
*/
private static class InnerClass{
private static final StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
}
private StaticInnerClassSingleton(){
System.out.println("StaticInnerClassSingleton初始化......");
}
public static StaticInnerClassSingleton getInstance(){
return InnerClass.staticInnerClassSingleton;
}
}
4. 饿汉式
如果不追求懒加载，那么还是使用类加载的同步控制的话，直接在单例类放一个静态变量，或者在静态代码块进行初始化。
public class HungrySingleton {
private static final HungrySingleton hungrySingleton ;
static {
hungrySingleton = new HungrySingleton();
}
private HungrySingleton(){
System.out.println("HungrySingleton初始化.....");
}
public static HungrySingleton getInstance(){
return hungrySingleton;
}
}5. 枚举
前面一步一步的推导出到了饿汉式，看着很完美了，但是单例模式会被反射破坏。通过反射获取到构造函数后，可以强制开启权限执行。序列化和反序列化也都是基于反射创建对象的。
那么什么单例模式不会有这样的情况呢？
枚举。枚举是最佳的单例模式实现方式。
枚举在底层的构造函数是强制private的，反射无法打开权限，枚举对象的反序列化是通过name在堆内找到对应的对象
public enum EnumSingleton implements Serializable {
EnumSingleton("枚举单例");
private String name;
EnumSingleton() {
}
EnumSingleton(String name) {
this.name = name;
}
public void doSomething(String something) {
System.out.println(name + ":" + something);
}
}
