1.可能大部分同学都知道，但为了少部分同学，我在老师这个单例上补个点。其它线程空指针异常确实是指令重排导致的，但其原因还有一个。加锁并不能阻止cpu调度线程执行体，所以时间片还是会切的（假设单核），所以其他线程依旧会执行锁外层的if（），并发情况下就可能拿到仅赋值引用，未在内存空间存储数据的实例（null实例），进而空指针。
2.给老师的代码补段骚的：
// 懒汉模式 + synchronized 同步锁 + double-check
public final class Singleton {
    private static validate Singleton instance = null;// 不实例化
    public List<String> list;//list 属性
    private Singleton(){
      list = new ArrayList<String>();
    }// 构造函数
    public static Singleton getInstance(){// 加同步锁，通过该函数向整个系统提供实例
        Singleton temp = instance；
        if(null == temp){// 第一次判断，当 instance 为 null 时，则实例化对象，否则直接返回对象
          synchronized （Singleton.class）{// 同步锁
             temp = instance；
             if(null == temp){// 第二次判断
                temp = new Singleton();// 实例化对象
                instance = temp；
             }
          }
        }
        return instance;// 返回已存在的对象
    }
}
用临时变量做方法内数据承载（相对于validate修饰的属性，可以减少从内存直接拷贝数据的次数），最后用instance接收临时变量时，因为是validate修饰，所以也不会有指令重排。所以前面临时变量的赋值操作已经完成，这样instance就必然是赋值好的实例。（如有错误请老师指出，仅个人理解的骚操作）

3.极限编程试试就好，业务代码还是尽量优先保证可读性，只有在有性能需求时再采用影响可读性的性能优化。我的这种骚写法和老师的内部类，这种看起来需要想那么一下的东西尽量避免，简单才是王道。

容器类管理

class InstanceManager {
    private static Map<String, Object> objectMap = new HashMap<>();
    private InstanceManager(){}
    public static void registerService(String key,Object instance){
        if (!objectMap.containsKey(key)){
            objectMap.put(key,instance);
        }
    }
    public static Object getService(String key){
        return objectMap.get(key);
    }
}

如果把这个成员变量的static去掉，在多线程情况下就可能创建多个实例，单线程没问题。老师，这么理解没问题吧？


// 饿汉模式
public final class Singleton {
    private Singleton instance=new Singleton();// 自行创建实例
    private Singleton(){}// 构造函数
    public static Singleton getInstance(){// 通过该函数向整个系统提供实例
        return instance;
    }
}

// 懒汉模式 + synchronized 同步锁 + double-check
public final class Singleton {
    private volatile static Singleton instance= null;// 不实例化
    public List<String> list = null;//list 属性
    private Singleton(){
      list = new ArrayList<String>();
    }// 构造函数
    public static Singleton getInstance(){// 加同步锁，通过该函数向整个系统提供实例
        if(null == instance){// 第一次判断，当 instance 为 null 时，则实例化对象，否则直接返回对象
          synchronized (Singleton.class){// 同步锁
             if(null == instance){// 第二次判断
                instance = new Singleton();// 实例化对象
             }
          }
        }
        return instance;// 返回已存在的对象
    }
}



这里不需要加 volatile

synchronized 遵循 happens before 原则，即 在 synchronized 块里的写，对后续其它线程的读是可见的。