单例模式

/**
 * 懒汉式
 * 实例在用到的时候才去创建，用的时候才去检查有没有实例，如果有则返回，没有则新建。有线程安全和线程不安全两种写法，区别就是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)