简介

一个类只有一个实例，分为懒汉模式和饿汉模式

例子

饿汉模式

//饿汉模式
public class Hungry {

    //私有化构造方式
    private Hungry(){}

    //初始化的时候，创建单例
    private static Hungry instance = new Hungry();

    //获取单例
    public static Hungry getInstance(){
        return instance;
    }

}

懒汉模式

//懒汉模式
public class Lazy {

    //私有化构造方法
    private Lazy(){}

    //初始化的时候不初始化单例
    private static Lazy lazy;

    //获取单例
    //该方法会经常调用，不建议使用synchronized同步
    public static Lazy getInstance(){
        if (lazy == null) {
            create();
        }
        return lazy;
    }

    //将创建进行同步，里面再进行判断，相对直接在getInstance上面做同步，效率要高些
    private synchronized static void create() {
        if (lazy == null) {
            System.out.println("创建单利");
            lazy = new Lazy();
        }
    }
}

测试结果

public class Main {
    public static void main(String[] args) {
        Hungry instance1 = Hungry.getInstance();
        Hungry instance2 = Hungry.getInstance();
        System.out.println(instance1 == instance2);
        //true,同一个实例

        for (int i = 0; i <= 10; i ++){
            new Thread(() -> {
                for (int j = 0; j <= 50; j ++) {
                    Lazy.getInstance();
                }
            }).start();
        }
        //创建单利
        //只打印了一次，证明创建成功
    }
}