单例模式，大致可分为五类：饿汉模式、懒汉模式、静态内部类、枚举、双重检查锁

饿汉模式

在类加载时就完成了初始化，加载较慢，但获取对象的速度快，没有线程安全问题

public class Singleton01 {private Singleton01(){}private static final Singleton01 INSTANCE = new Singleton01();public static Singleton01 getInstance(){return INSTANCE;}
}

 饿汉模式变种

public class Singleton02 {private Singleton02(){}private static final Singleton02 INSTANCE;static {INSTANCE = new Singleton02();}public static Singleton02 getInstance() {return INSTANCE;}}

懒汉模式

在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢，有线程安全问题

public class Singleton03 {private Singleton03(){}private static Singleton03 INSTANCE;public static Singleton03 getInstance(){if(INSTANCE == null){INSTANCE = new Singleton03();}return INSTANCE;}}

加锁饿汉模式

加锁解决了线程安全问题，但性能较差

public class Singleton04 {private Singleton04(){}private static Singleton04 INSTANCE;public static synchronized Singleton04 getInstance(){if(INSTANCE == null){INSTANCE = new Singleton04();}return INSTANCE;}
}

锁粒度小的懒汉模式

锁粒度缩小了，性能得到提升，但带来了线程安全问题

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

双重检查模式

锁粒度小，同时没有线程安全问题

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

静态内部类

不加锁，同时也没有线程安全问题，很完美

public class Singleton07 {private Singleton07(){}private static class Singleton07Holder{private final static Singleton07 INSTANCE = new Singleton07();}public static Singleton07 getInstance(){return Singleton07Holder.INSTANCE;}
}

枚举方式

没线程安全问题，同时可以防止通过序列化创建多个实例

public enum Singleton08 {INSTANCE;
}