01 定义

单例模式：确保一个类只有一个实例，并提供一个全局访问点。

02 线程安全下的三种实现方式

01 饿汉式

public class Singleton {
    // 类加载时,就进行对象实例化。
    // 缺点：类加载时就初始化，浪费内存。
    private static final Singleton singleton = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return singleton;
    }
}

02 懒汉式 (不推荐）

public class Singleton {

    private static Singleton singleton;

    private Singleton(){}

    // 添加synchronized关键字，确保不会有两个线程同时进入该方法。
    // 缺点：只有第一次执行此方法时，才真正需要同步。之后每次调用此方法，同步都是一种累赘，严重降低性能。
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

03 双重检查加锁

public class Singleton {
    // volatile关键字确保singleton变量被初始化成Singleton实例时，多个线程能正确的处理singleton变量。
    private volatile static Singleton singleton;

    private Singleton(){}

    public static Singleton getInstance(){
        // 双重检查加锁，这样只有第一次才会同步。
        if(singleton == null){
            synchronized (Singleton.class){
                if (singleton == null){
                    singleton = new Singleton();
                }
            }
        }

        return singleton;
    }
}

04 使用静态内部类

public class Singleton {

    private Singleton(){}

    public static final Singleton getInstance(){
        return SingletonHolder.singleton;
    }

    // 静态内部类
    private static class SingletonHolder{
        private static final Singleton singleton = new Singleton();
    }
}