1.饿汉式（线程安全，调用效率高，不能延时加载）
public class SingletonDemo {
private static SingletonDemo instance=new SingletonDemo();
private SingletonDemo(){}
public static SingletonDemo getInstance(){
return instance;
}
}
2.懒汉式（线程安全，调用效率不高，能延时加载）
public class SingletonDemo2 {
//类初始化时，不初始化这个对象(延时加载，真正用的时候再创建)
private static SingletonDemo2 instance;
//构造器私有化
private SingletonDemo2(){}
//方法同步，调用效率低
public static synchronized SingletonDemo2 getInstance(){
if(instance==null){
instance=new SingletonDemo2();
}
return instance;
}
}
3.双重锁
public class SingletonDemo3 {
//volatile防止指令重排序，内存可见(缓存中的变化及时刷到主存，并且其他的内存失效，必须从主存获取)
private volatile static SingletonDemo3 instance;
private SingletonDemo3() {
}
public static SingletonDemo3 getInstance() {
//第一次判断，假设会有好多线程，如果 instance 没有被实例化，那么就会到下一步获取锁，只有一个能获取到，
//如果已经实例化，那么直接返回了，减少除了初始化时之外的所有锁获取等待过程
if (instance == null) {
synchronized (SingletonDemo3.class) {
//第二次判断是因为假设有两个线程A、B,两个同时通过了第一个if，然后A获取了锁，进入然后判断 instance 是null，他就实例化了instance，然后他出了锁，
//这时候线程B经过等待A释放的锁，B获取锁了，如果没有第二个判断，那么他还是会去new SingletonDemo3()，再创建一个实例，所以为了防止这种情况，需要第二次判断
if (instance == null) {
instance = new SingletonDemo3();
}
}
}
return instance;
}
}
4.静态内部类（线程安全，调用效率高，可以延时加载）
public class SingletonDemo4 {
private static class SingletonHolder{
private static final SingletonDemo4 instance = new SingletonDemo4();
}
private SingletonDemo4(){}
public static SingletonDemo4 getInstance(){
return SingletonHolder.instance;
}
}
1.静态内部类如何实现线程安全
虚拟机会保证一个类的<clinit>()（类构造器方法）方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。
2.静态内部类能保证对象唯一性、线程安全又能延迟加载，是不是完美
由于是静态内部类的形式去创建单例的，故外部无法传递参数进去，传参问题 是一大缺点。
5.枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用）
public enum SingletonDemo5 {
//枚举元素本身就是单例
INSTANCE;
//添加自己需要的操作
public void singletonOperation(){
}
}
