5种类型的单例模式

/**
 * 1、懒汉式(是线程不安全的)
 */
class Singleton
{
    private static Singleton instance;
    public Singleton(){}
    public static Singleton getInstance()
    {
        if(instance==null) return new Singleton();
        return instance;
    }
}
/**
 * 2、懒汉式(是线程安全的，但是效率非常低)
 */
class Singleton1
{
    private static  Singleton1 instance;
    public Singleton1(){}
    public static synchronized Singleton1 getInstance()
    {
        if(instance==null) return new Singleton1();
        return instance;
    }
}

/**
 * 3、饿汉式(虽然避免了线程安全，但是导致类装在的原因很多，不能够实现lazyloading效果)
 */
class Singleton2
{
    private static  Singleton2 instance=new Singleton2();
    public Singleton2(){}
    public static  Singleton2 getInstance()
    {
        return instance;
    }
}

/**
 * 饿汉式，与3实现的效果类似
 */
class Singleton2_1 {  
    private static Singleton2_1 instance = null;  
    static {  
        instance = new Singleton2_1();  
    }  
    private Singleton2_1 (){}
    public static Singleton2_1 getInstance() {  
        return instance;  
    }  
} 

/**
 * 4、静态内部类
 */
class Singleton3 {  
    private static class SingletonHolder {  
        private static final Singleton3 INSTANCE = new Singleton3();  
    }  
    private Singleton3 (){}
    public static final Singleton3 getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}

/**
 *5、双重校验锁
 */
class Singleton4 {  
    private volatile static Singleton4 singleton;  //防止对象创建过程重新排序
　　//构造函数私有，防止外部实例化
    private Singleton4 (){}   
    public static Singleton4 getSingleton() {  
        if (singleton == null) {  
            synchronized (Singleton4.class) {  
                if (singleton == null) {  
                    singleton = new Singleton4();  
                }  
            }  
        }  
        return singleton;  
    }  
}  

双重锁定参考文章：https://www.cnblogs.com/tangZH/p/10031337.html