vlambda博客
学习文章列表

What

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

Why

为什么我们需要单例这种设计模式？它能解决哪些问题？
从业务概念上，有些数据在系统中只应该保存一份，就比较适合设计为单例类。比如，系统的配置信息类。除此之外，我们还可以使用单例解决资源访问冲突的问题。

How

那么，如何实现一个单例类呢？总结起来，有以下5种方法实现一个单例类。

饿汉式

public class HungrySingleton {
    private String content;
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {
        content = "This is a singleton object from hungry type";
    }

    public static HungrySingleton getInstance() {
        return instance;
    }

    public String getContent() {
        return content;
    }
}

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

懒汉式

public class LazySingleton {
    private String content;
    private static LazySingleton instance;

    private LazySingleton() {
        content = "This is a singleton object from lazy type";
    }

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

    public String getContent() {
        return content;
    }
}

懒汉式相对于饿汉式的优势是支持延迟加载。这种实现方式会导致频繁加锁、释放锁，以及并发度低等问题，频繁的调用会产生性能瓶颈。

双重检查

public class DoubleCheckSingleton {
    private String content;
    private static volatile DoubleCheckSingleton instance;

    private DoubleCheckSingleton() {
        content = "This is a singleton object from double-check type";
    }

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

    public String getContent() {
        return content;
    }
}

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

静态内部类

public class StaticInnerClassSingleton {
    private String content;

    private StaticInnerClassSingleton() {
        content = "This is a singleton object from static inner class type";
    }

    public String getContent() {
        return content;
    }

    public static class StaticInnerClassSingletonHolder {
        public static final StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance() {
        return StaticInnerClassSingletonHolder.staticInnerClassSingleton;
    }
}

利用 Java 的静态内部类来实现单例。这种实现方式，既支持延迟加载，也支持高并发，实现起来也比双重检测简单。

枚举类

public enum EnumSingleton {
    INSTANCE;
    private String content = "This is a singleton object from enum type";

    public String getContent() {
        return content;
    }
}

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

代码地址

https://github.com/FudanYuan2019/i-learning/tree/master/i-design-pattern/src/main/java/singleton

写在最后

如果你觉得我写的文章帮到了你，欢迎点赞、评论、分享、赞赏哦，你们的鼓励是我不断创作的动力～