单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象

饿汉式

public class HungrySingleton {
    private HungrySingleton() {
    }
    //线程安全，可能会浪费空间，开辟了空间，却没有使用
    private static  HungrySingleton HungrySingleton = new HungrySingleton();
    public static  HungrySingleton getInstance(){
        return HungrySingleton;
    }
}

懒汉式，线程不安全

public class LazySingleton1 {
    private LazySingleton1() {
    }

    private static LazySingleton1 LazySingleton1;
//线程不安全，不支持多线程,
    public static LazySingleton1 getInstance(){
        if (LazySingleton1==null){
            LazySingleton1=new LazySingleton1();
        }
        return LazySingleton1;
    }
}

懒汉式，线程安全

public class LazySingleton2 {
    private LazySingleton2() {
    }

    private static LazySingleton2 LazySingleton2;
// 线程安全，效率低
    public static synchronized LazySingleton2 getInstance(){
        if (LazySingleton2==null){
            LazySingleton2 = new LazySingleton2();
        }

        return LazySingleton2;
    }
}

双检锁/双重校验锁

public class LazySingleton3 {
    private LazySingleton3() {
    }

    private static LazySingleton3 LazySingleton3;

//    这种方式采用双锁机制，安全且在多线程情况下能保持高性能
    public static LazySingleton3 getInstance(){
        if(LazySingleton3==null) {
            synchronized (LazySingleton3.class) {
                if (LazySingleton3 == null) {
                    LazySingleton3 = new LazySingleton3();
                }

            }
        }
        return LazySingleton3;

    }
}

登记式/静态内部类

public class StaticClassSingleton {

    private StaticClassSingleton() {
    }
//这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用
    private static class SingletonHolder {
        private static final StaticClassSingleton StaticClassSingleton=new StaticClassSingleton();
    }

    public static StaticClassSingleton getInstance(){
        return SingletonHolder.StaticClassSingleton;
    }
}

枚举

public enum  EnumSingle {
    single;
//    自动支持序列化机制，绝对防止多次实例化
    public EnumSingle getInstance(){
        return single;
    }
}