单例的几种常见的形式

饿汉式：直接创建对象，创建及加载

1.直接实例化

public class Singleton1 {
    //单例模式
    //饿汉式：创建及加载
    //直接实例化懒汉式

    //构造器私有化
    //自行创建，并且用静态变量保存
    //向外提供这个实例
    //强调这是一个单例，使用final修饰
    public static final Singleton1 INSTANCE = new Singleton1();

    private Singleton1() {

    }
}

2.枚举式

public enum Singleton2 {
    //单例模式
    //饿汉式：创建及加载
    //枚举式
    INSTANCE


}

3.静态代码块

public class Singleton3 {
    //单例模式
    //饿汉式：创建及加载
    //静态代码块

    public static final Singleton3 INSTANCE ;

    static {
        INSTANCE = new Singleton3();
    }
    private Singleton3(){
        
    }
}

静态代码块与直接实例化不同之处在于在静态代码块可以进行其他操作，例如从配置文件读取内容等等。

懒汉式：延迟创建对象，调用才加载

1.线程不安全

public class Singleton4 {
    //单例模式
    //懒汉式：调用才加载
    //线程不安全

    //构造器私有化
    //用一个静态变量保存这个实例
    //提供静态方法获取这个实例

    private static Singleton4 INSTANCE ;

    private Singleton4(){

    }

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

2.线程安全

public class Singleton5 {

    //单例模式
    //懒汉式：调用才加载
    //线程安全

    //构造器私有化
    //用一个静态变量保存这个实例
    //提供静态方法获取这个实例

    private Singleton5(){

    }

    private static Singleton5 INSTANCE;

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

}

3.静态内部类

public class Singleton6 {
    //单例模式
    //懒汉式：调用才加载
    //静态内部类形式

    private Singleton6(){

    }

    private static class Inner {
        private static final Singleton6 INSTANCE = new Singleton6();
    }

    public static Singleton6 getInstance(){
        return Inner.INSTANCE;
    }
}