单例模式的七种创建方式

• 单例模式保证一个类仅有一个实例
• 单例类必须自己创建自己的唯一实例
• 单例类提供一个静态的获取方式(通常使用getInstance()这个方法名)

第一种饿汉式

public class Singleton {

    private static final Singleton instance = new Singleton();

    public Singleton() {
        //Empty
    }

    public static Singleton getInstance() {
        return instance;
    }
}

在上述代码中可以获取到类的唯一实例,但是当JVM加载的过程中就会将此实例初始化,但是如果没有使用到这个实例,就会造成内存浪费.此方法可以使用但不建议使用

第二种懒汉式

public class LazySingleUnSafe {

    private static LazySingleUnSafe instance;

    private LazySingleUnSafe() {

    }

    public static LazySingleUnSafe getInstance() {
        //一个线程进入了if (null == instance)判断语句块，还未来得及往下执行，
        // 另一个线程也通过了这个判断语句
        if (null == instance) {
            return new LazySingleUnSafe();
        }
        return LazySingleUnSafe.instance;
    }
}

上述方法解决了第一种饿汉式的问题,但是只可以在单线程模式下使用,如果在多线程中,当第一个线程在判断

if (null == instance)

这一句为True时,可能第二个线程也判断为Ture,就会创建多个实例.所以多线程情况下不可使用

第三种 懒汉式加锁

public class LazySingleSafe {

    private static LazySingleSafe instance;

    private LazySingleSafe() {

    }

    // 在这里加锁 但是影响性能
    public synchronized static LazySingleSafe getInstance() {
        if (null == instance) {
            return new LazySingleSafe();
        }
        return LazySingleSafe.instance;
    }
}

这种方式可以解决第二种模式的问题,但是每次都会判断锁的状态,所以性能差

第四种 DoubleCheck 模式

public class LazySingleDoubleCheck {

    private static LazySingleDoubleCheck instance;

    private LazySingleDoubleCheck() {

    }
    //只有在两个线程同时抢锁的时候
    public static LazySingleDoubleCheck getInstance() {

        if (null == instance) {
            synchronized (LazySingleDoubleCheck.class) {
                if (null == instance) {
                    return new LazySingleDoubleCheck();
                }
            }
        }
        return LazySingleDoubleCheck.instance;
    }
}

这种方式解决了第三种模式将锁加到方法上性能差的问题,当判断实例存在的时候直接返回创建好的对象,而不是判断锁的状态. 就算有两个线程同时判断 instance 为null,但是new实例的过程中加了锁,也会只有一个线程会创建实例对象,但是如果在实际开发中,如果此实例的内部属性很多,实例化需要很长时间时,当对象还在实例化的时候,如果有第二个线程通过getInstance()方法来取此实例,就会取到null值.

第五种 DoubleCheck+ volatile 的方式

public class LazySingleDoubleCheckNotNull {

    //在这里加 volatile 保证有序 保证可见性 在读的时候必须保证他已经写完
    private static volatile LazySingleDoubleCheckNotNull instance;

    private LazySingleDoubleCheckNotNull() {
    }

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

这一种方式和第四种比 就加了一个 volatile 关键字.
volatile 关键字保证了在第二个线程来读的时候实例已经完全被写完(关于此关键字 后续会重点说明)

第六种 创建静态内部类的方式

public class SingleInnerClass {


    private SingleInnerClass() {
    }

    //外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE 调用的时候只创建一个 所以单例
    private static class InstanceHolder {
        private final static SingleInnerClass instance = new SingleInnerClass();
    }

    public static SingleInnerClass getInstance() {
        return InstanceHolder.instance;
    }
}

JVM在加载外部类的时候,并不会立即加载内部类,而是当调用的时候再去加载,所以就类似之前的懒汉模式,而且JVM加载机制保证了线程安全,所以这种方式推荐使用.

第七种 用枚举的方式

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

我们定义的一个枚举，在第一次被真正用到的时候，会被虚拟机加载并初始化，而这个初始化过程是线程安全的(关于类加载器 后续会重点说明)