单例模式的六种写法

饿汉式三种：

（饿汉式不存在线程安全问题）

1.直接饿汉式：

public class Singleton{
    private Singleton(){};//构造方法私有化
    public static final Singleton INSTANCE = new Singleton();//提供一个可访问的静态常量引用
}

2.枚举类型的饿汉式：

public enum Singleton{
    INSTANCE; //枚举类型：表示该类的对象是有限的几个，我们可以限定为一个，就成了单例。
}

3.静态代码块饿汉式：

public class Singleton{
    public static final Singleton INSTANCE;
    private Singleton(){};
    static{          
            INSTANCE = new Singleton();
            // .....其他的操作。这种方式适合在初始化阶段还要做一些其他的操作。
    }
}

懒汉式三种：

1.线程不安全：

public class Singleton{
    private Singleton(){};
    private static Singleton instance;
    public static getInstance(){ //提供对外可访问的静态工厂方法
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

2.双端检测式（线程安全）：

public class Singleton {
	private Singleton() {};//构造函数私有化
	private volatile static Singleton instance = null;//用volatile修饰防止指令重排
	//静态工厂方法
	public static Singleton getInstance() {
		if(instance == null) { //双重检查机制
			synchronized (Singleton.class) { //同步锁
				if(instance == null) {//双重检查机制
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

3.静态内部类实现（线程安全）

public class Singleton{
    private Singleton(){};
    //在外部无法访问静态内部类，静态内部类不会随之外部类的加载和初始化而加载初始化，而是在
    //调用getInstance方法是才被加载。所以是线程安全的
    private static class InnerClass{
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance(){
        return InnerClass.INSTANCE;
    }
}

利用反射打破单例

//第一步，获得单例类的构造器。
Constructor con = Singleton.class.getDeclaredConstructor();
//第二步，把构造器设置为可访问。
con.setAccessible(true);
//第三步，使用newInstance方法构造对象
Singleton singleton1 = (Singleton)con.newInstance();
Singleton singleton2 = (Singleton)con.newInstance();
//验证是否是不同对象
System.out.println(singleton1 == singleton2);