社区首页 >专栏 >单例模式（上）

单例模式（上）

WindCoder

发布于 2020-04-28 02:31:16

44500

代码可运行

文章被收录于专栏：WindCoderWindCoder

运行总次数：0

代码可运行

1. 什么是

一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式（Singleton Design Pattern）。

2. 为何用

2.1 处理资源访问冲突

单例模式相对于之前类级别锁的好处是，不用创建那么多 Logger 对象，一方面节省内存空间，另一方面节省系统文件句柄（对于操作系统来说，文件句柄也是一种资源，不能随便浪费）。

2.2 表示全局唯一类

从业务概念上，如果有些数据在系统中只应保存一份，那就比较适合设计为单例类。

大部分情况下，我们在项目中使用单例，都是用它来表示一些全局唯一类，比如配置信息类、连接池类、ID 生成器类。

单例模式书写简洁、使用方便，在代码中，我们不需要创建对象，直接通过类似 IdGenerator.getInstance().getId() 这样的方法来调用就可以了。

3. 怎样实现

相关文章 Java设计模式学习笔记—单例模式（上） Java设计模式学习笔记—单例模式（下）并发学习笔记11-双重检查锁定与延迟初始化

3.1 饿汉模式

饿汉式的实现方式，在类加载的期间，就已经将 instance 静态实例初始化好了，所以，instance 实例的创建是线程安全的。
这样的实现方式不支持延迟加载实例。

public class IdGenerator1 {
    private AtomicLong id = new AtomicLong(0);
    private static final IdGenerator1 instantce = new IdGenerator1();

    private IdGenerator1(){}


    public static IdGenerator1 getInstance() {
        return instantce;
    }

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

3.2 懒汉模式

懒汉式相对于饿汉式的优势是支持延迟加载。

这种实现方式使用了synchronized 锁，导致函数的并发度很低，即会导致频繁加锁、释放锁，以及并发度低等问题，频繁的调用会产生性能瓶颈，此种情况下该方法便不可取。

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

    private IdGenerator2(){}


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

        return instance;
    }

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

}

3.3 双重检测

双重检测实现方式既支持延迟加载、又支持高并发的单例实现方式。只要 instance 被创建之后，再调用 getInstance() 函数都不会进入到加锁逻辑中。所以，这种实现方式解决了懒汉式并发度低的问题。

public class IdGenerator3 {

    private AtomicLong id = new AtomicLong(0);
    // private static  IdGenerator3 instance;
    private static volatile IdGenerator3 instance;

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

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

3.3.1 volatile关键字的作用

指令重排序，可能会导致 IdGenerator 对象被 new 出来，并且赋值给 instance 之后，还没来得及初始化（执行构造函数中的代码逻辑），就被另一个线程使用了。

故给 instance 成员变量加上 volatile 关键字，禁止指令重排序，从而解决该问题。

然而设计模式之美中有这样一段话：

只有很低版本的 Java 才会有这个问题。我们现在用的高版本的 Java 已经在 JDK 内部实现中解决了这个问题（解决的方法很简单，只要把对象 new 操作和初始化操作设计为原子操作，就自然能禁止重排序）。

关于这段话在网上暂未找到相关依据，《深入理解JVM虚拟机（第三版）》中涉及双重检测的部分也没看到有关于此的相关改动，实力有限，暂且存疑。

3.5 静态内部类

利用 Java 的静态内部类来实现单例。这种实现方式

支持延迟加载
支持高并发
实现起来也比双重检测简单

public class IdGenerator4 {

    private AtomicLong id = new AtomicLong(0);

    private IdGenerator4(){}

    private static class SingletonHolder {
        private static final  IdGenerator4 instance = new IdGenerator4();
    }

    public static IdGenerator4 getInstance(){

        return SingletonHolder.instance;
    }

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

3.6 枚举

最简单的实现方式，基于枚举类型的单例实现。

这种实现方式通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。

public enum IdGenerator5 {
    INSTANCE;
    private AtomicLong id = new AtomicLong(0);
    public long getId() {
        return id.incrementAndGet();
    }
}