单例模式 Java实现（5种）

方式1：懒汉模式（不好）
描述：只适用于单线程环境 多个线程访问 可能会创建多个对象

public class Singleton1{
    private static Singleton1 instance;

    }
    public static Singleton1 getInsatnce(){
        if(null == instance){
            instance = new Singleton1();
        }
        return instance;
    }
}

线程安全的懒汉模式 （不好）
描述：这种方式每次获取实例都会加一个同步锁，加锁是一个耗时的操作 所以这个方式工作效率比较低

public class Singleton2 {
    private static Singleton2 instance;
    private Singleton2(){

    }
    public static synchronized Singleton2 getInsatnce(){
        if(null == instance){
            instance = new Singleton2();
        }
        return instance;
    }
}

方式2：加同步锁,前后两次判断实例是否已2经存在 (可行)
描述：这种方式只有在实例为null的时候需要加锁 当时实例创建出来就不需要在加锁了，这样效率比Singleton2要好很多，但是这样的代码实现起来比较复杂，容易出错。

public class Singleton3 {
    private volatile static Singleton3 instance;
    private Singleton3(){
        System.out.println("实例已经创建！！！");
    }
    public static Singleton3 getInsatnce(){
        if(null == instance){
            synchronized (Singleton3.class) {
                if(null == instance){
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }
}

方式3：饿汉模式(建议使用)
描述：没有懒加载 降低内存使用率

public class Singleton4 {
    private static Singleton4 instance = new Singleton4();
    private Singleton4(){
        System.out.println("实例已经创建！！！");
    }
    public static Singleton4 getInsatnce(){
        return instance;
    }
}

方式4：枚举(建议使用)

public enum Singleton6 {
    INSTANCE;
    public static Singleton6 getInstance(){
        return Singleton6.INSTANCE;
    }
}

方式5：静态内部类(建议使用)
描述：在内部静态类方案中，对象的加载也是懒汉模式，使用内部类的classloader机制来保证线程安全性。在java虚拟机中，类的生命周期包括装载连接和初始化。jvm会保证对类的初始化过程被同步的进行。

public class Singleton5 {
    private static class SingletonHolder{
        private static final Singleton5 INSTANCE = new Singleton5();
    }
    private Singleton5(){
        System.out.println("实例已经创建！！！");
    }
    public static Singleton5 getInsatnce(){
        return SingletonHolder.INSTANCE;
    }
}