单例模式

//单例 饿汉模式:创建一个静态实例,私有化构造器,这个是线程安全的
public class Sington {
    private static final Sington INSTANCE=new Sington();
    //私有化构造器
    private Sington(){

    }

    public Sington getInstance(){
        return INSTANCE;
    }
}

//单例 懒汉方式
public class Sington {
    private static  Sington INSTANCE=null;

    private Sington(){}

    public static Sington getInstance(){
        if(null==INSTANCE){
            //线程不安全方式,多个线程同时进入这里的话,会创建多个对象
            INSTANCE= new Sington();
        }
        return INSTANCE;
    }
    //线程安全,但每次获取对象都要获取锁,实际上只要第一个请求访问获取了对象后,之后请求不用再创建对象了,因此这种方式会导致效率变低
    public static synchronized Sington getInstance2(){
        if(null==INSTANCE){
            INSTANCE = new Sington();
        }
        return INSTANCE;
    }


    public static Sington getInstance3(){
        if(null==INSTANCE){
            //多个请求可以同时到达这里,之后都会执行下面代码,只是排队执行,因此还是不安全
            synchronized (Sington.class){
                INSTANCE= new Sington();
            }
        }
        return INSTANCE;
    }
    //双重判断
    public static Sington getInstance4(){
        if(null==INSTANCE){
            //多个请求可以同时到达这里,然后排队进下面方法
            synchronized (Sington.class){
                if(null==INSTANCE){ //多个请求排队进入该方法后,只要第一个创建了对象,后面的请求就不会创建对象了,因为此时INSTANCE已经不为空了
                    INSTANCE= new Sington();
                }
            }
        }
        return INSTANCE;
    }

}
//静态内部类实现单例模式,这个会懒加载并且线程安全
public class Sington {


    private Sington(){}

    private static class SingtonInstance{
        private static final Sington INSTANCE=new Sington();
    }

    public Sington getInstance(){
        return SingtonInstance.INSTANCE;
    }

}
//枚举实现单例模式
public enum SingtonEnum {
    INSTANCE
}