对单例模式的理解（上）

博主个人博客网站：文客
如果你想每天和我交流技术，可以关注一下我的个人博客网站：文客，我会每天在这里更新技术文章和面试题，也会及时收到大家的评论与留言，欢迎各位大佬来交流！

什么是单例模式？

单例设计模式，顾名思义：就是一个类只允许创建一个对象或实例，那么这样的类我们通常叫做单例类，这种设计模式也就叫做单例模式。

单例模式的概念如此简单，它的应用也是比较简单的。如果有些数据在系统中只应该保存一份，或者根据特定的业务需求，我们通常会考虑到单例模式。

设想一下，我们要实现一个递增的id号码生成器，如果系统中存在两个id生成器对象，那么就可能会出现id号重复的情况，所以我们应该把id生成器设计为单例。但是话又说回来了，如果你的系统需要有多种多样的id生成器，那么单例模式可能并不是最佳的选择，所以还是要根据具体的需求来决定。

如何实现单例模式？

现在网络上有海量的关于单例模式的文章，线程单例、进程单例和分布式单例都有很详细的文章，但是回归本质，我们为什么要用到单例模式呢？单例模式有哪些关注点？概括起来，单例模式的关注点有如下几个：

• 构造函数应该是私有的，即private的，这样才能避免外部通过new的方式来创建对象，从而破坏单例
• 考虑对象创建时的线程安全问题
• 考虑是否支持延迟加载
• 考虑getInstance()性能是否高（是否加锁）

1.饿汉式

对于了解过单例模式的人来说，饿汉式描述这种实现方式再合适不过了，对于不了解单例模式的人来说，可能就有些发懵了。

其实这就是一个形象的比喻，主要是在是否支持延迟加载这一环节。我们把我们的系统比作一个饿汉，他非常的饥饿，所以我们最好在类加载的时候就把单例对象创建出来，以填饱他的肚子。

顺着这个思路，我们把单例对象声明为静态，并且在类加载时就初始化，代码如下：

public class IdGenerator {
    private AtomicLong id = new AtomicLong(0);
    private static final IdGenerator instance = new IdGenerator();

    private IdGenerator(){}

    public static IdGenerator getInstance(){
        return instance;
    }

    public Long getId(){
        return id.incrementAndGet();
    }
}

从代码中可以看出，饿汉式单例模式在类加载时就会初始化单例对象。关于饿汉式，较大的争议点在于：如果实例占用的资源较多，或者初始化工作较为繁琐，可能在类加载时实例化会浪费资源。其实个人认为也是分具体场景，如果单例对象比较常用的话，我们最好不要等到用的时候再去初始化，这样会使得我们的请求时间变长，甚至是超时。如果应用频率不是很高，那可以采取延迟加载的形式，一定程度上优化了性能。

在实例占用资源较多，初始化工作比较繁琐时，按照fail-fast的原则，我们也希望在程序启动时就将这个类初始化比较好。如果资源不够，系统根据fail-fast机制，会尽早的暴露问题，我们可以立即去修复，而不是在用户使用某个功能时突然发生了错误或者系统崩溃。

对于fail-fast，之前的面试题专栏中也有说过，它既是一种机制，又是一种设计原则。程序中某些潜在的风险，我们有时会本着越早暴露越好的原则，这样可以避免风险引发的一系列错误。

比如集合中的fail-fast机制：它是一种异常检测机制，一般Java集合中都会维护一个modCount变量，当一个线程使用iterator对集合进行遍历时，另一个线程移除了集合中的元素或者改变的集合的结构，此时程序就会发现expectedmodCount和modCount不一致，就会抛出ConcurrentModificationException（并发修改异常）。

2.懒汉式

懒汉式与饿汉式刚好相反，我们把系统比作一个懒汉，他非常懒，什么事都不想自己做，不会提前准备好可能需要的资源，等有需求时，他才会交付相应的对象。

顺着思路我们写代码：

public class Lazy_IdGenerator {
    private AtomicLong id = new AtomicLong(0);
    private static Lazy_IdGenerator instance;

    private Lazy_IdGenerator(){}

    public static synchronized Lazy_IdGenerator getInstance(){
        if(instance == null){
            instance = new Lazy_IdGenerator();
        }
        return instance;
    }

    public long getId(){
        return id.incrementAndGet();
    }
}

可以看出懒汉式支持懒加载，但是缺点也很明显，它的getInstance()方法加了synchronized，导致并发度很低，如果这个单例对象经常被调用的话，会导致性能瓶颈。

3.双重检测

饿汉式不支持懒加载，懒汉式不支持高并发。那有没有既支持延迟加载，又支持高并发的实现方式呢？

先来看代码：

public class DoubleCheck_IdGenerator {
    private AtomicLong id = new AtomicLong(0);
    private static DoubleCheck_IdGenerator instance;

    private DoubleCheck_IdGenerator() {}

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

    public long getId(){
        return id.incrementAndGet();
    }
}

在这种实现方式中，只要instance被创建后，即便再调用getInstance()函数也不会再进入加锁逻辑中了。

但是这种方式仍存在一个问题，在我们的视角中new一个DoubleCheck_IdGenerator是一个操作，但是在JVM中，它是很多个操作。首先，先会在内存中开辟一块空间，并且赋予instance，然后再调用DoubleCheck_IdGenerator的构造函数进行初始化操作（我也是在较粗粒度的角度解释的，其实步骤不止如此）。在指令重排的作用下，很可能instance还没来得及初始化，就被另一个线程使用了。

要解决这个问题，我们当然要想办法禁止指令重排，所以我们给instance家上volatile关键字。实际上，只有很低版本的Java才会有这个问题，我们现在用的高版本的Java已经在JDK内部中解决了这个问题，解决办法也很简单：将new操作和初始化操作设计为原子操作。

更改后的代码如下：

public class DoubleCheck_IdGenerator {
    private AtomicLong id = new AtomicLong(0);
    private static volatile DoubleCheck_IdGenerator instance;

    private DoubleCheck_IdGenerator() {}

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

    public long getId(){
        return id.incrementAndGet();
    }
}

4.静态内部类

利用Java的静态内部类，可以完成一个比双重检测更简单的实现方法。我们来看他的实现代码：

public class Inner_IdGenerator {
    private AtomicLong id = new AtomicLong(0);

    private Inner_IdGenerator(){}

    private static class SingletonClass{
        private static final Inner_IdGenerator instance = new Inner_IdGenerator();
    }

    public static Inner_IdGenerator getInstance(){
        return SingletonClass.instance;
    }

    public long getId(){
        return id.incrementAndGet();
    }
}

SingletonClass是一个静态内部类，当外部类Inner_IdGenerator被加载时，并不会创建SingletonClass对象，只有当调用getInstance()方法时，SingletonClass才会被加载，这个时候创建instance。instance的唯一性与线程安全性都由JVM来保证，既保证了线程安全又完成了延迟加载。

5.枚举

枚举实现的单例模式，通过Java枚举类型本身的特性，保证了单例模式的线程安全性和对象唯一性。代码如下：

public enum Enum_IdGenerator {
    INSTANCE;
    private AtomicLong id = new AtomicLong(0);

    public long getId(){
        return id.incrementAndGet();
    }
}

博客原文地址

对单例模式的理解（上）