1.饿汉
private static Singleton instance=new Singleton();
或
private static Singleton instance=null;
static {
instance=new Singleton();
}
其实就是在类加载时，准备阶段里把类的属性实例化，缺点是可能提前加载到内存。
2.线程不安全的懒汉
private static Singleton instance；
其实就是没有任何锁，用的时候再去判断并初始化，有可能在判断为空和执行初始化期间，别的线程完成了初始化
3.线程安全的懒汉
private static Singleton instance；
public synchronized Singleton getInstance(){}
其实就是为静态方法加了类锁，凡是用这个静态函数的，一律加锁，缺点就是锁阻塞，影响效率
4.双重校验锁
private volatile static Singleton instance;
private void Singleton(){}
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
if(instance==null){
instance=new Singleton();
}
}
}
}
用synchronized来实现锁同步的实例化，因为获取锁之后会更新一次数据，所以要再检查一次instance是否为空
注意，使用volatile主要是为了实现有序性，instance=new Singleton();实际上是3个指令（分配内存+实例化+指向引用），有可能遇到指令重排序导致出错的问题，volatile会通过内存屏障，禁止重排序，顺便可以用来实现可见性，减少资源消耗。
5.静态内部类
private static class SingletonHolder{
private static final Singleton instance=new Singlton();
}
public static Singleton getInstance(){
return SingletonHolder.instance;
}
private void Singlton(){}
其实就是利用类的主动加载机制，只有在使用到静态类的对象时，才去加载类，这样静态内部类一定是在getInstance时加载。
另外，静态对象虽然天然只有方法区的一个实例，但也有被修改的可能，所以用final确保线程安全。
静态内部类相比内部类来说，不能直接调用宿主类的函数，但是也拥有内部类的访问权限，所以不受private限制
6.枚举
public enum EnumSingleton{
INSTANCE;
private Singleton instance;
private EnumSingleton(){
instance=new Singleton();
}
public Singleton getInstance(){
return instance;
}
}
其实就是因为枚举类型是static final类型，而且只能实例化一次，原理上其实和静态内部类的写法一样。
单元素的枚举类型已经成为实现Singleton的最佳方法。
多个classloader破坏单例
不同classloader加载的类不是同一个类，所以要避免多个classloader加载出多个单例对象。
这种情况下，可以考虑用当前线程的ClassLoader来加载类。
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
反射破坏单例
因为反射可以拿到constructor构造函数，所以调用构造函数的newInstance方法能破坏单例：
//获得构造器
Constructor con = Singleton.class.getDeclaredConstructor();
//设置为可访问
con.setAccessible(true);
//构造新的对象
Singleton singleton1 = (Singleton)con.newInstance();
对于需要构造函数的单例写法来说，因为只是在正常情况下屏蔽了构造函数，所以可以用反射访问到构造函数，破坏单例；
只有枚举单例不能被反射破坏，因为枚举单例在编译后，其实是abstract类，无法初始化，而且Java在newInstanc时对Enum禁止。
反序列化破坏单例
如果单例是可序列化的，就很容易通过反序列化得到多个单例对象。因为ObjectInputStream的readResolve函数会反射执行构造函数，绕过单例的代码限制机制。
注意，枚举单例不能implement Serializable，否则readObject的特性“每次都返回新建的实例”会破坏单例。
这种情况下，可以考虑修改readResolve函数，返回饿汉的静态单例对象。
public static Singleton INSTANCE = new Singleton();
private Object readResolve() {
return INSTANCE;
}
构造函数报错
根据Initialization-on-demand holder idiom的提示，使用内部静态类这种单利写法时，需要确保构造函数不抛异常，例如：
private SingletonClass() {
throw new RuntimeException("exception in constructor");
}
文章声称，这种情况会导致调用报错，NoClassDefFoundError。
不过，当我们实际测试一下两次调用，会发现两次报错不一样：
第一次报错其实是ExceptionInInitializerError，这是因为第一次调用SingletonClass.getInstance()时，需要加载目标类（懒加载），在加载过程中，执行构造函数失败，所以报错会是ExceptionInInitializerError。
第二次报错因为第一次加载类失败，类只会加载一次，而第一次的加载过程失败了，所以会报NoClassDefFoundError，找不到目标类。
