单例模式详解

1.饿汉式：类加载就会导致该单实例对象被创建

1.1 静态变量方式：

public class Singleton {

    private Singleton(){
    }
    //在本类中创建本类对象
    private static Singleton instance = new Singleton();
    //提供一个公共的访问方式,让外界获取该对象,必须用静态方法,因为外界无法创建Singleton对象就不能访问非静态方法。
    public static Singleton getInstance(){
        return instance;
    }
}

1.2 静态代码块方式

public class Singleton {

    private Singleton(){}//让外界不能创建该类的对象

    private static Singleton instance;

    static {
        instance = new Singleton();
    }
    public static Singleton getInstance(){
        return instance;
    }
}

缺点：内存的浪费

2.懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会被创建。

2.1 线程不安全

public class Singleton {

    private Singleton(){}

    //声明Singleton类型的变量
    private static Singleton instance;//只是声明该类的变量，并没有进行赋值

    //对外提供访问方式
    public static Singleton getInstance(){
        if(instance == null){//判断instance是否为null
            //线程1等待，线程2获取到cpu执行权，创建的就不是一个对象了
            instance = new Singleton();
        }
        return instance;
    }
}

2.2 线程安全

public class Singleton {

    private Singleton(){}

    //声明Singleton类型的变量
    private static Singleton instance;//只是声明该类的变量，并没有进行赋值

    //对外提供访问方式
    public static synchronized Singleton getInstance(){//加同步锁
        if(instance == null){//判断instance是否为null
            
            instance = new Singleton();
        }
        return instance;
    }
}

缺点：锁力度大，导致性能低下。

2.3 双重检查锁方式

public class Singleton {

    private Singleton(){}

    private static Singleton instance;

    public static Singleton getInstance(){
        //第一次判断,如果instance不为null，不需要抢占锁。直接返回对象
        if(instance == null){
            synchronized (Singleton.class){
                //第二次判断
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

缺点：多线程情况下，可能出现空指针问题，JVM在实例化对象的时候会进行优化和指令重排序操作。

2.4 双重检查方式

public class Singleton {

    private Singleton(){}

    private static volatile Singleton instance;

    public static Singleton getInstance(){
        //第一次判断,如果instance不为null，不需要抢占锁。直接返回对象
        if(instance == null){
            synchronized (Singleton.class){
                //第二次判断
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

推荐使用这种。

2.5 静态内部类方式

public class Singleton {

    private Singleton(){}

    private static class SingletonHolder{//在JVM在加载外部类的过程中，不会加载静态内部类，
        // 只要内部类的属性或方法被调用时才会加载。
        //在内部类中声明并初始化外部类的对象
        private static final Singleton INSTANCE = new Singleton();
    }

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

3.枚举方式：恶汉式，枚举类型是线程安全的，并且只会装载一次。

3.1 枚举类型

public enum Singleton {
    
    INSTANCE;
}

太神奇了！！不考虑浪费内存空间可以选这个。