你确定你的单例模式真的用对了？

一、什么是单例模式

单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。该类负责创建自己的对象，同时确保只有一个对象被创建。一般常用在工具类的实现或创建对象需要消耗资源的业务场景。

单例模式的特点：

1.类构造器私有

2.持有自己类的引用

3.对外提供获取实例的静态方法

我们先用一个简单示例了解一下单例模式的用法。

public class SimpleSingleton {
    //持有自己类的引用
    private static final SimpleSingleton INSTANCE = new SimpleSingleton();

    //私有的构造方法
    private SimpleSingleton() {

    }
    //对外提供获取实例的静态方法
    public static SimpleSingleton getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        System.out.println(SimpleSingleton.getInstance().hashCode());
        System.out.println(SimpleSingleton.getInstance().hashCode());
    }
}

打印结果：

1639705018

我们看到两次获取SimpleSingleton实例的hashCode是一样的，说明两次调用获取到的是同一个对象。

可能很多朋友平时工作当中都是这么用的，但是我要说的是这段代码其实是有问题的。

你确定你的单例模式真的用对了？

private static final SimpleSingleton INSTANCE = new SimpleSingleton();

一开始就实例化对象了，如果实例化过程非常耗时，并且最后这个对象没有被使用，不是白白造成资源浪费吗？

这个时候你也许会想到，如果在真正使用的时候再实例化不就可以了？这就是我接下来要介绍的 懒汉模式。

二、饿汉模式与懒汉模式

什么是饿汉模式？

实例在初始化的时候就已经建好了，不管你有没有用到，都先建好了再说。好处是没有线程安全的问题，坏处是浪费内存空间。代码如下：

public class SimpleSingleton {
    //持有自己类的引用
    private static final SimpleSingleton INSTANCE = new SimpleSingleton();

    //私有的构造方法
    private SimpleSingleton() {

    }
    //对外提供获取实例的静态方法
    public static SimpleSingleton getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        System.out.println(SimpleSingleton.getInstance().hashCode());
        System.out.println(SimpleSingleton.getInstance().hashCode());
    }
}

什么是懒汉模式？

顾名思义就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则返回，没有则新建。代码如下：

public class SimpleSingleton2 {


    private static SimpleSingleton2 INSTANCE;

    private SimpleSingleton2() {

    }

    public static SimpleSingleton2 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new SimpleSingleton2();
        }
        return INSTANCE;
    }
    public static void main(String[] args) {
        System.out.println(SimpleSingleton2.getInstance().hashCode());
        System.out.println(SimpleSingleton2.getInstance().hashCode());
    }
}

示例中的INSTANCE对象一开始是空的，在调用getInstance方法才会真正实例化。

如果代码可能有些朋友在使用，但是还是有问题。

有什么问题呢？

假如有多个线程中都调用了getInstance方法，那么都走到 if (INSTANCE == null) 判断时，可能同时成立，因为INSTANCE初始化时默认值是null。这样会导致多个线程中同时创建INSTANCE对象，即INSTANCE对象被创建了多次，违背了一个INSTANCE对象的初衷。

要如何改进呢？

最简单的办法就是使用synchronized关键字，改进后的代码如下：

public class SimpleSingleton3 {

    private static SimpleSingleton3 INSTANCE;

    private SimpleSingleton3() {

    }

    public synchronized static SimpleSingleton3 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new SimpleSingleton3();
        }
        return INSTANCE;
    }
    public static void main(String[] args) {
        System.out.println(SimpleSingleton3.getInstance().hashCode());
        System.out.println(SimpleSingleton3.getInstance().hashCode());
    }
}

这样总可以了吧？

不好意思，还是有问题。

你确定你的单例模式真的用对了？

有什么问题？

使用synchronized关键字会消耗性能，我们应该判断INSTANCE为空时才加锁，而不为空不应该加锁，需要直接返回。这就需要使用双重检查锁。

饿汉模式和懒汉模式各有什么优缺点？

饿汉模式：好处是没有线程安全的问题，坏处是浪费内存空间。

懒汉模式：好处是没有内存空间浪费的问题，但是控制不好实际不是单例。

三、双重检查锁

双重检查锁顾名思义会检查两次，在加锁之前检查一次是否为空，加锁之后再检查一次是否为空。代码如下：

public class SimpleSingleton4 {


    private static SimpleSingleton4 INSTANCE;

    private SimpleSingleton4() {

    }

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

    public static void main(String[] args) {
        System.out.println(SimpleSingleton4.getInstance().hashCode());
        System.out.println(SimpleSingleton4.getInstance().hashCode());
    }
}

在加锁之前判断是否为空，可以确保INSTANCE不为空的情况下，不用加锁，可以直接返回。

为什么在加锁之后，还需要判断INSTANCE是否为空呢？

其实，是为了防止在多线程并发的情况下，比如：线程a 和线程b同时调用

getInstance，同时判断INSTANCE为空，则同时进行抢锁。假如线程a先抢到锁，开始执行synchronized关键字包含的代码，此时线程b处于等待状态。线程a创建完新实例了，释放锁了，此时线程b拿到锁，进入synchronized关键字包含的代码，如果没有再判断一次INSTANCE是否为空，则可能会重复创建实例。

不要以为这样就完了，还有问题呢？

你确定你的单例模式真的用对了？

有啥问题？

  public static SimpleSingleton4 getInstance() {
        if (INSTANCE == null) {//1
            synchronized (SimpleSingleton4.class) {//2
                if (INSTANCE == null) {//3
                    INSTANCE = new SimpleSingleton4();//4
                }
            }
        }
        return INSTANCE;//5
    }

getInstance方法的这段代码，我是按1、2、3、4、5这种顺序写的，希望也按这个顺序执行。但是java虚拟机实际上会有一些优化，对一些代码指令进行重排。重排之后的顺序可能就变成了：1、3、2、4、5，这样在多线程的情况下同样会创建多次实例。重排之后的代码可能如下：

public static SimpleSingleton4 getInstance() {
        if (INSTANCE == null) {//1
           if (INSTANCE == null) {//3
               synchronized (SimpleSingleton4.class) {//2
                    INSTANCE = new SimpleSingleton4();//4
                }
            }
        }
        return INSTANCE;//5
    }

原来如此，那有什么办法可以解决呢？

可以在定义INSTANCE是加上volatile关键字，代码如下：

public class SimpleSingleton7 {


    private volatile static SimpleSingleton7 INSTANCE;

    private SimpleSingleton7() {

    }

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

    public static void main(String[] args) {
        System.out.println(SimpleSingleton7.getInstance().hashCode());
        System.out.println(SimpleSingleton7.getInstance().hashCode());
    }
}

volatile 关键字可以保证多个线程的可见性，但是不能保证原子性。同时它也能禁止指令重排。

双重检查锁的机制既保证了线程安全，又比直接上锁提高了执行效率，还节省了内存空间。

除了上面的单例模式之外，还有没有其他的单例模式？

四、静态内部类

静态内部类顾名思义是通过静态的内部类来实现单例模式的。

public class SimpleSingleton5 {

    private SimpleSingleton5() {
    }

    public static SimpleSingleton5 getInstance() {
        return Inner.INSTANCE;
    }

    private static class Inner {
        private static final SimpleSingleton5 INSTANCE = new SimpleSingleton5();
    }

    public static void main(String[] args) {
        System.out.println(SimpleSingleton5.getInstance().hashCode());
        System.out.println(SimpleSingleton5.getInstance().hashCode());
    }
}

我们看到在SimpleSingleton5类中定义了一个静态的内部类Inner，SimpleSingleton5类的getInstance方法返回的是内部类Inner的实例INSTANCE。

只有第一次调用getInstance方法时，虚拟机才加载 Inner 并初始化INSTANCE ，只有一个线程可以获得对象的初始化锁，其他线程无法进行初始化，保证对象的唯一性。

五、枚举

枚举是天然的单例，每一个实例只有一个对象，这是java底层内部机制保证的。

public enum  SimpleSingleton6 {
    INSTANCE;

    public void doSameThing() {

    }
}

但是实际情况下，枚举的单例用的并不多，因为它不好理解。

六、总结

本文主要介绍了：

饿汉模式、懒汉模式、双重检查锁、静态内部类和枚举这5种单例模式，各有优缺点，静态内部类是所有单例模式中最推荐的模式。

如果您看了这篇文章觉得有所收获，帮忙关注一下我的公众账号：苏三说技术。

一、什么是单例模式

二、饿汉模式与懒汉模式

三、双重检查锁

四、静态内部类

五、枚举

六、总结​

Andriod第三方源码分析

Android进阶之旅-(Framework源码分析)

热门文章

六、总结