/**
* 懒汉式
* 实例在用到的时候才去创建，用的时候才去检查有没有实例，如果有则返回，没有则新建。有线程安全和线程不安全两种写法，区别就是synchronized关键字
*/
public class LazyMode {
private static LazyMode lazyMode;
private LazyMode() {
}
public static synchronized LazyMode getLazyModeInstance() {
if (lazyMode == null) {
lazyMode = new LazyMode();
}
return lazyMode;
}
}
/**
* 饿汉式
* 实例在初始化的时候就已经建好了，不管有没有用到先建好了再说。好处是没有线程安全的问题，坏处是浪费内存空间。
*/
public class HungryMode {
private static HungryMode mode = new HungryMode();
private HungryMode() {
}
public static HungryMode getHungryModeInstance() {
return mode;
}
}
/**
* 双重检查锁
* 结合懒汉式和饿汉式两者的优缺点，特点是在synchronized关键字内外都加了一层if条件判断，这样既保证了线程安全，又比直接上锁提高了执行效率，还节省了内存空间。
*
* 问题1： 为什么两次判空
* 第一个判断避免了不必要的同步，减少性能开销
* 第二个判空避免生成多个对象实例
*
* 比如三个线程A，B，C，假设线程A和线程B同时调用getSingleton()时，判断第一层if判断都为空，这时线程A先拿到锁，线程B在代码块外层等待。
* 线程A进行第二层if判断，new了一个新对象，创建完成释放锁，线程B拿到锁，进行第二层if判断，singleton不为空，直接返回singleton释放锁，避免生成多个对象实例。
* 线程线C调用getSingleton时第一层判断不成立，直接拿到singleton对象返回，避免进入锁，减少性能开销。
*
* 问题2：为什么要用volatile关键字
* 如果不用volatile，并发情况下会出现问题，线程A进入new TestInstance() 的时候，分为：1.分配内存、2.初始化对象、3.mInstance指向内存 三步，
* 此时若发生指令重排，执行顺序是132，执行到第3的时候，线程B刚好进来了，并且执行到注释2，并没有进入synchronized代码块，synchronized修饰的是代码块，不是整个方法。这时候判断mInstance不为空，直接使用一个未初始化的对象会报错。
*/
public class DoubleCheckMode {
private static volatile DoubleCheckMode mode;
private DoubleCheckMode() {
}
public static DoubleCheckMode getDoubleCheckModeInstance() {
if (mode == null) { //2
synchronized (DoubleCheckMode.class) {
if (mode == null) {
mode = new DoubleCheckMode();
}
}
}
return mode;
}
}
/**
* 静态内部类
* 因为内部类是私有的，所以除了get方法外，没有办法访问它，同时static和final是JVM本身的机制保证了线程的安全，同时它在性能上也没有损耗
*/
public class Singleton {
public Singleton() {
}
public static Singleton getInnerStaticMode() {
return SingletonHolder.INSTANCE;
}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
}
/**
* 枚举
* 自动支持序列化机制，绝对防止多次实例化。同时包括静态内部类的优点
*/
public enum EnumSingleton {
INSTANCE;
public void doSomeThing() {
}
}
https://www.jianshu.com/p/f3fae8658f13 如何实现一个线程安全的单例，前提是不能加锁
面试官：说说多线程并发问题 - 掘金 (juejin.cn)
