单例模式的几种实现方式及对比

所谓单例就是在系统中只有一个该类的实例。
单例模式的核心分以下三个步骤：

1. 构造方法私有化。即不能在类外实例化，只能在类内实例化。
2. 在本类中创建本类的实例。
3. 在本类中提供给外部获取实例的方式。

单例模式的实现方式有两种：饿汉模式和懒汉模式。

饿汉模式

不管现在需不需要，先创建实例。关键在于“饿”，饿了就要立即吃。

静态常量

这里将类的构造器私有化，就不能在外部通过new关键字创建该类的实例，然后定义了一个该类的常量，用static修饰，以便外部能够获得该类实例（通过HungryStaticConstantSingleton.INSTANCE 获得）。也可以不加final关键字，具体看自己的需求。

/**
 * 恶汉模式-静态常量，简洁直观
 */
public class HungryStaticConstantSingleton{
    //构造器私有化
    private HungryStaticConstantSingleton() {
    }
    //静态变量保存实例变量 并提供给外部实例
    public final static HungryStaticConstantSingleton INSTANCE = new HungryStaticConstantSingleton();
}

 

枚举

这种方式是最简洁的，不需要考虑构造方法私有化。值得注意的是枚举类不允许被继承，因为枚举类编译后默认为final class，可防止被子类修改。常量类可被继承修改、增加字段等，容易导致父类的不兼容。

/**
 * 恶汉-枚举形式，最简洁
 */
public enum HungryEnumSingleton{
    INSTANCE;
    
    public void print(){
        System.out.println("这是通过枚举获得的实例");
        System.out.println("HungryEnumSingleton.pring()");
    }
}

 

Test，打印实例直接输出了【INSTANCE】，是因为枚举帮我们实现了toString，默认打印名称。

public class EnumSingleton2Test{
    public static void main(String[] args) {
        HungryEnumSingleton singleton2 = HungryEnumSingleton.INSTANCE;
        System.out.println(singleton2);
        singleton2.print();
    }
}

 输出结果

 

静态代码块

这种方式和上面的静态常量/变量类似，只不过把new放到了静态代码块里，从简洁程度上比不过第一种。但是把new放在static代码块有别的好处，那就是可以做一些别的操作，如初始化一些变量，从配置文件读一些数据等。

/**
 * 恶汉模式-静态代码块
 */
public class HungryStaticBlockSingleton{

    //构造器私有化
    private HungryStaticBlockSingleton() {
    }

    //静态变量保存实例变量
    public static final HungryStaticBlockSingleton INSTANCE;

    static {
        INSTANCE = new HungryStaticBlockSingleton();
    }
}

 

如下，在static代码块里读取 info.properties 配置文件动态配置的属性，赋值给 info 字段。

/**
 * 恶汉模式-静态代码块
 * 这种用于可以在静态代码块进行一些初始化
 */
public class HungryStaticBlockSingleton{

    private String info;

    private HungryStaticBlockSingleton(String info) {
        this.info = info;
    }

    //构造器私有化
    private HungryStaticBlockSingleton() {
    }

    //静态变量保存实例变量
    public static final HungryStaticBlockSingleton INSTANCE;

    static {
        Properties properties = new Properties();
        try {
            properties.load(HungryStaticBlockSingleton.class.getClassLoader().getResourceAsStream("info.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        INSTANCE = new HungryStaticBlockSingleton(properties.getProperty("info"));
    }
    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
}

 

Test，

public class HungrySingletonTest{
    public static void main(String[] args) {
        HungryStaticBlockSingleton hun = HungryStaticBlockSingleton.INSTANCE;
        System.out.println(hun.getInfo());
    }
}

 

输出

 

懒汉模式

需要时再创建，关键在于“懒”，类似懒加载。

非线程安全

同样是构造方法私有化，提供给外部获得实例的方法，getInstance()方法被调用时创建实例。该方式适用于单线程，因为在多线程的情况下可能会发生线程安全问题，导致创建不同实例的情况发生。可以看下面的演示。

/**
 * 懒汉模式-线程不安全的，适用于单线程
 */
public class LazyUnsafeSingleton{
    private LazyUnsafeSingleton(){
    }
    private static LazyUnsafeSingleton instance;
    public static LazyUnsafeSingleton getInstance(){
        if(instance==null){
            instance = new LazyUnsafeSingleton();
        }
        return instance;
    }
}

非线程安全演示

public class LazyUnsafeSingletionTest{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(2);
        Callable<LazyUnsafeSingleton> c1 = new Callable<LazyUnsafeSingleton>(){
            @Override
            public LazyUnsafeSingleton call() throws Exception {
                return LazyUnsafeSingleton.getInstance();
            }
        };
        Callable<LazyUnsafeSingleton> c2 = new Callable<LazyUnsafeSingleton>(){
            @Override
            public LazyUnsafeSingleton call() throws Exception {
                return LazyUnsafeSingleton.getInstance();
            }
        };
        Future<LazyUnsafeSingleton> submit = es.submit(c1);
        Future<LazyUnsafeSingleton> submit1 = es.submit(c2);
        LazyUnsafeSingleton lazyUnsafeSingleton = submit.get();
        LazyUnsafeSingleton lazyUnsafeSingleton1 = submit1.get();
        es.shutdown();

        System.out.println(lazyUnsafeSingleton);
        System.out.println(lazyUnsafeSingleton);
        System.out.println(lazyUnsafeSingleton1==lazyUnsafeSingleton);
    }
}

 

输出 大概运行三次就会出现一次，我们可以在 LazyUnsafeSingleton 中判断 if(instance==null) 之后增加线程休眠以获得更好的效果。

线程安全的

该方式是懒汉模式中线程安全的创建方式。通过同步代码块控制并发创建实例。并且采用双重检验，当两个线程同时执行第一个判空时，都满足的情况下，都会进来，然后去争锁，假设线程1拿到了锁，执行同步代码块的内容，创建了实例并返回，此时线程2又获得锁，执行同步代码块内的代码，因为此时线程1已经创建了，所以线程2虽然拿到锁了，如果内部不加判空的话，线程2会再new一次，导致两个线程获得的不是同一个实例。线程安全的控制其实是内部判空在起作用，至于为什么要加外面的判空下面会说。

/**
 * 懒汉模式-线程安全，适用于多线程
 */
public class LazySafeSingleton{
    private static volatile LazySafeSingleton safeSingleton;//防止指令重排
    private LazySafeSingleton() {
    }
    public static LazySafeSingleton getInstance(){
        if(safeSingleton==null){
            synchronized (LazySafeSingleton.class){
                if(safeSingleton==null){//双重检测
                    safeSingleton = new LazySafeSingleton();
                }
            }

        }
        return safeSingleton;
    }
}

 当不加内层判空时，会出现不是单例的情况，只不过出现的概率更低了点。

可不可以只加内层判空呢？答案是可以。

那为什么还要加外层判空的呢？内层判空已经可以满足线程安全了，加外层判空的目的是为了提高效率。因为可能存在这样的情况：线程1拿到锁后执行同步代码块，在new之后，还没有释放锁的时候，线程2过来了，它在等待锁（此时线程1已经创建了实例，只不过还没释放锁，线程2就来了），然后线程1释放锁后，线程2拿到锁，进入同步代码块汇总，判空，返回。这种情况线程2是不是不用去等待锁了？所以在外层又加了一个判空就是为了防止这种情况，线程2过来后先判空，不为空就不用去等待锁了，这样提高了效率。

内部类创建外部类实例

该方式天然线程安全，是否final根据自己需要。

/**
 * 懒汉模式-线程安全，适用于多线程
 * 在内部类被加载和初始化时 才创建实例
 * 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独加载和初始化的。
 * 因为是在内部类加载和初始化时创建的 因此它是线程安全的
 */
public class LazyInnerSingleton{
    private LazyInnerSingleton() {
    }
    private static class Inner{
        private static final LazyInnerSingleton INSTANCE = new LazyInnerSingleton();
    }
    public static LazyInnerSingleton getInstance(){
        return Inner.INSTANCE;
    }
}

 

总结

饿汉模式

• 静态常量 简洁直观容易理解
• 枚举 最简洁
• 静态代码块 可以在静态块里做一些初始化的工作

懒汉模式

• 单线程形式 该形式下不适用多线程，存在线程安全问题
• 多线程形式 适用于多线程
• 内部类形式 最简洁