单例模式

饿汉模式

/**
 * 单例-饿汉模式
 * 类被加载的时候就把对象实例化了
 * <p>
 * 优点：
 * 1、实现简单
 * 2、线程安全的
 * 缺点：
 *  * 1、没有懒加载，在不需要的此实例的时候就已经把实例创建出来了
 *
 * @author zc
 * @date 2020/9/5 00:54
 */
public class SingletonA {
    private static final SingletonA INSTANCE = new SingletonA();

    private SingletonA() {
    }

    public static SingletonA getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        SingletonA instance1 = SingletonA.getInstance();
        SingletonA instance2 = SingletonA.getInstance();
        System.out.println(instance1 == instance2);
    }
}

---

懒汉模式

/**
 * 单例-懒汉模式
 * 需要用到的时候再去创建实例
 * <p>
 * 优点：
 * 1、实现简单
 * 缺点：
 * 1、线程不安全的。在并发获取实例的时候，可能会存在构建了多个实例的情况
 *
 * @author zc
 * @date 2020/9/5 01:11
 */
public class SingletonB {
    private static SingletonB INSTANCE = null;

    private SingletonB() {
    }

    public static SingletonB getInstance() {
        if (null == INSTANCE) {
            INSTANCE = new SingletonB();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        SingletonB instance1 = SingletonB.getInstance();
        SingletonB instance2 = SingletonB.getInstance();
        System.out.println(instance1 == instance2);
    }
}

---

懒汉模式-双重效验

/**
 * 单例-懒汉模式-双重效验
 * 需要用到的时候再去创建实例
 * volatile关键字来修饰singleton，其最关键的作用是防止指令重排
 * 双重校验的方式，对懒汉式单例模式做了线程安全处理。
 * 通过加锁，可以保证同时只有一个线程走到第二个判空代码中去，这样保证了只创建 一个实例。
 * <p>
 * 优点：
 * 1、实现简单
 * 2、线程安全
 *
 * @author zc
 * @date 2020/9/5 01:11
 */
public class SingletonBSafe {

    private static volatile SingletonBSafe INSTANCE = null;

    private SingletonBSafe() {
    }

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

    public static void main(String[] args) {
        SingletonBSafe instance1 = SingletonBSafe.getInstance();
        SingletonBSafe instance2 = SingletonBSafe.getInstance();
        System.out.println(instance1 == instance2);
    }
}

---

枚举

/**
 * 单例-枚举
 *
 * @author zc
 * @date 2020/9/5 01:17
 */
public class SingletonC {

    private SingletonC() {
    }

    enum SingletonCEnum {
        /**
         * 创建一个枚举对象，该对象天生为单例
         */
        INSTANCE;
        private SingletonC singletonC;

        SingletonCEnum() {
            singletonC = new SingletonC();
        }
    }

    public static SingletonC getInstance() {
        return SingletonCEnum.INSTANCE.singletonC;
    }

    public static void main(String[] args) {
        SingletonC instance1 = SingletonC.getInstance();
        SingletonC instance2 = SingletonC.getInstance();
        System.out.println(instance1 == instance2);
    }
}