单例设计模式实现的几种方式

1.饿汉模式，静态常量方式

饿汉模式避免了线程同步的问题，因为它是在类加载的时候就进行了对象的创建
缺点：容易造成资源浪费

public class Single{
    private static final Single instance = new Single();
    private Single(){
    }
    public static Single getInstance(){
        return instance;
    }
}

静态代码块的方式

public class Single{
    private Single(){
    }
    private static Single instance;
    static{
        instance = new Single();
    }
    public static Single getInstance(){
        return instance;
    }
}

2.懒汉式

线程不安全的方式，以下代码中虽然解决了懒加载但是线程不安全，当线程A判断成功了却失去了cpu这时线程B又判断通过，这时会出现多个实例

class Single{
    private static Single instance;
    private Single(){
    }
    public static Single getInstance(){
        if(instance == null){
            instance = new Single();
        }
        return instance;
    }
}

加入synchronized解决线程同步问题
缺点：每次进来一个线程都要进行线程同步过后在进行判断，效率低下

public class Single{
    private static Single instance;
    private Single(){
    }
    public static synchronized Single getInstance(){
        if(instance == null){
            instance = new Single();
        }
        return instance;
    }
}

双重检查的方式,(推荐使用)，既解决了懒加载又提升了效率

class Single{
    private static volatile Single instance;
    private Single(){
    }
    public static Single getInstance(){
        if(instance == null){
            synchronized (Single.class){
                if(instance == null){
                    instance = new Single();
                }
            }
        }
        return instance;
    }
}

3.静态内部类的方式(推荐使用)

在这里当调用 getInstance方法的时候会加载静态类，而jvm加载类是线程安全的，在类加载的时候其他线程无法进入，因此这里避免了线程不安全和实现了懒加载

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

}

4.使用枚举，可以解决线程安全，而且防止反序列化创建对象(强烈推荐)

enum  Single{
   INSTACE;
   public void test(){
       System.out.println("测试代码");
   }

}