单例设计模式

• 饿汉式 ：线程安全（普通）

Class Singleton{
    private Singleton(){}               //1.私有构造函数
    private static Singleton instance = new Singleton ();     //2.创建本类对象
    public static Singleton getInstance(){          //3.对外提供公共的访问方式
        return instance;
    }
}

• 懒汉式：线程不安全（普通）

public class Singleton {

　　private Singleton(){}; //1.私有构造函数

　　private static Singleton instance; //2.声明一个本类的引用

　　public static Singleton getInstance(){ //3.对外提供公共的访问方式

　　　　if(instance == null){

　　　　　　instance = new Singleton();

　　　　}

　　　　return instance;

　　}

}

• 饿汉式：线程安全（使用static final修饰，不能被更改）

class Singleton {
    private Singleton(){};
    public static final Singleton s = new Singleton();      //被final修饰的变量不能被更改    
}

• 静态内部类：线程安全 （使用内部类）

public class Singleton {
    private Singleton() {
    }
    
    public static Singleton getInstance() {
        return SingletonHolder.mInstance;
    }
    
    private static class SingletonHolder {
        private static final Singleton mInstance = new Singleton();
    }
}

• 懒汉模式：线程安全（volatile和sync修饰）

public class Singleton {
    public volatile static Singleton singleton = null;
    private Singleton(){ //构造方法私有化，防止外部调用生成实例化,比如反射
        if(singleton!=null){
            throw new RuntimeException("此类对象为单例模式，已经被实例化");
        }
    }

    /**
     * 1.为什么会有线程不安全的问题？
     * 如果不加同步块，那么线程A抢到走到此if (singleton == null) 停了，线程B此时抢到了就new了一个对象，当线程B
     * 走完了，线程A就接着此if (singleton == null)继续执行，此时就又new了一个对象，这样就导致new了两个对象
     * 2.为什么加了同步块，外层还要加此句判断？
     * 因为如果当是单线程的时候也会同步了，就影响了性能
     */
    public static Singleton getSingleton(){
        if(singleton==null) {
            synchronized (Singleton.class) { //通过反射：类名.class 得到Class类对象
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}