单例模式讨论

单例模式的意图是为了确保一个类有且仅有一个实例，并未他提供一个全局访问点(分布式集群下不适用)。

#懒汉模式

/**
 * @description: 懒汉模式
 *               优点：实例被使用时才会创建，节省内存
 * 				 缺点：线程不安全
 * @create: 2021-11-17 17:44
 */
public class SingletonDemo {

    private static SingletonDemo instance;

    private SingletonDemo(){};

    public static SingletonDemo getInstance(){
        if(instance == null){
            instance = new SingletonDemo();
        }
        return instance;
    }
}

#加同步锁synchronized的懒汉模式

/**
 * @description: 加同步锁的懒汉模式
 * @create: 2021-11-19 10:24
 */
public class SingletonDemo3 {

    private SingletonDemo3(){};

    private static SingletonDemo3 singletonDemo3 = null;

    public synchronized static SingletonDemo3 getInstance(){
        if(singletonDemo3 == null){
            singletonDemo3 = new SingletonDemo3();
        }
        return singletonDemo3;
    }
}

#饿汉模式

/**
 * @description: 饿汉模式
 *               优点：由于类是按需加载，且只加载一次，避免了线程安全问题(!!!多JVM/ClassLoader的系统使用单例类，需要注意单例对象的状态，最好使用无状态的单例类)
 *               缺点：浪费内存空间
 * @create: 2021-11-19 10:17
 */
public class SingleDemo2 {
    private SingleDemo2(){}

    private static SingleDemo2 singleDemo2 = new SingleDemo2();

    public static SingleDemo2 getInstance(){
        return singleDemo2;
    }
}

#双检锁模式

/**
 * @description: 双检锁模式 :  综合懒汉模式和硬汉模式
 * 							
 * @create: 2021-11-19 10:32
 */
public class SingletonDemo4 {

    private SingletonDemo4(){}

    private volatile static SingletonDemo4 singletonDemo4 = null;

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

volatile关键子作用参考：link
link

#静态内部类模式

/**
 * @description: 静态内部类模式:类似于饿汉模式，利用类加载保证线程安全同时之创建一个实例，同样注意过jvm和classloader的问题
 * @create: 2021-11-19 10:41
 */
public class SingletonDemo5 {
    private SingletonDemo5(){}

    private static class Singleholder{
        private static final SingletonDemo5 singletonDemo5 = new SingletonDemo5();
    }

    public static final SingletonDemo5 getInstance(){
        return Singleholder.singletonDemo5;
    }
}

一台机器（操作系统）能启动多个JVM进程，各个JVM进程有独自的数据空间和代码空间，互不影响,并且每调用java命令之后（执行启动类的main函数），就是启动一个JVM实例。