设计模式学习笔记--单例模式(详细笔记)

最新推荐文章于 2024-03-22 19:17:14 发布

Gangbb

最新推荐文章于 2024-03-22 19:17:14 发布

阅读量1k

点赞数 1

分类专栏：设计模式文章标签：单例模式设计模式 java 软件设计

本文链接：https://blog.csdn.net/qq_37132495/article/details/121857289

版权

设计模式专栏收录该内容

23 篇文章 3 订阅

订阅专栏

文章目录

1. 概述

使用背景：

《大话设计模式》

通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

菜鸟教程

一个全局使用的类频繁地创建与销毁。当您想控制实例数目，节省系统资源的时候。

定义：

菜鸟教程

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

《图说设计模式》

单例模式(Singleton Pattern)：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

类型:创建型

结构：

《大话设计模式》

refactoringguru.cn

类比实例：

菜鸟教程

一个班级只有一个班主任。
Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
政府是单例模式的一个很好的示例。一个国家只有一个官方政府。不管组成政府的每个人的身份是什么， “某政府” 这一称谓总是鉴别那些掌权者的全局访问节点。

适用场景：

《图说设计模式》

系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器，或者需要考虑资源消耗太大而只允许创建一个对象。
客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。
在一个系统中要求一个类只有一个实例时才应当使用单例模式。反过来，如果一个类可以有几个实例共存，就需要对单例模式进行改进，使之成为多例模式

refactoringguru.cn

如果程序中的某个类对于所有客户端只有一个可用的实例，可以使用单例模式。
单例模式禁止通过除特殊构建方法以外的任何方式来创建自身类的对象。该方法可以创建一个新对象，但如果该对象已经被创建，则返回已有的对象。
如果你需要更加严格地控制全局变量，可以使用单例模式。
单例模式与全局变量不同，它保证类只存在一个实例。除了单例类自己以外，无法通过任何方式替换缓存的实例。

请注意，你可以随时调整限制并设定生成单例实例的数量，只需修改 获取实例方法，即 getInstance 中的代码即可实现。

实现方式：

refactoringguru.cn

在类中添加一个私有静态成员变量用于保存单例实例。
声明一个公有静态构建方法用于获取单例实例。
在静态方法中实现"延迟初始化"。该方法会在首次被调用时创建一个新对象，并将其存储在静态成员变量中。此后该方法每次被调用时都返回该实例。
将类的构造函数设为私有。类的静态方法仍能调用构造函数，但是其他对象不能调用。
检查客户端代码，将对单例的构造函数的调用替换为对其静态构建方法的调用。

优点：

慕课网教程

在内存里只有一个实例，减少了内存开销
可以避免对资源的多重占用
设置全局访问点，严格控制访问

《大话设计模式》

单例模式因为Singleton类封装它的唯一实例，这样它可以严格地控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问。

菜鸟教程

在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
避免对资源的多重占用（比如写文件操作）。

《图说设计模式》

提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它，并为设计及开发团队提供了共享的概念。
由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
允许可变数目的实例。我们可以基于单例模式进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例。

refactoringguru.cn

你可以保证一个类只有一个实例。
你获得了一个指向该实例的全局访问节点。
仅在首次请求单例对象时对其进行初始化。

缺点：

菜鸟教程

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

《图说设计模式》

由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。
滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致对象状态的丢失。

refactoringguru.cn

违反了单一职责原则。该模式同时解决了两个问题。
单例模式可能掩盖不良设计，比如程序各组件之间相互了解过多等。
该模式在多线程环境下需要进行特殊处理，避免多个线程多次创建单例对象。
单例的客户端代码单元测试可能会比较困难，因为许多测试框架以基于继承的方式创建模拟对象。由于单例类的构造函数是私有的，而且绝大部分语言无法重写静态方法，所以你需要想出仔细考虑模拟单例的方法。要么干脆不编写测试代码，或者不使用单例模式。

使用注意：

慕课网教程

私有构造器
线程安全
延迟加载
序列化和反序列化安全
反射

菜鸟教程

单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。

《图说设计模式》

单例类的构造函数为私有；
提供一个自身的静态私有成员变量；
提供一个公有的静态工厂方法。

与其他设计模式的联系：

慕课网教程

其他模式结合:

单例模式和工厂模式
单例模式和享元模式

refactoringguru.cn

外观模式类通常可以转换为单例模式类，因为在大部分情况下一个外观对象就足够了。
如果你能将对象的所有共享状态简化为一个享元对象，那么享元模式就和单例类似了。但这两个模式有两个根本性的不同。
- 只会有一个单例实体，但是享元类可以有多个实体，各实体的内在状态也可以不同。
- 单例对象可以是可变的。享元对象是不可变的。
抽象工厂模式、生成器模式和原型模式都可以用单例来实现。

2. 代码实现

2.1 静态类实现

《重学Java设计模式》

public class Singleton_00 {

    public static Map<String,String> cache = new ConcurrentHashMap<String, String>();
    
}

分析：

以上这种方式在我们平常的业务开发中非常场常见，这样静态类的方式可以在第一次运行的时候直接初始化Map类，同时这里我们也不需要到延迟加载在使用。
在不需要维持任何状态下，仅仅用于全局访问，这个使用使用静态类的方式更加方便。
但如果需要被继承以及需要维持一些特定状态的情况下，就适合使用单例模式。

2.2 懒汉式(线程不安全)

package com.gangbb.creational.singleton;

/**
 * @author Gangbb
 * @date 2021/4/19 11:49
 * @Description: 单例模式懒汉式
 */
public class LazySingleton {
    private static LazySingleton lazySingleton = null;

    private LazySingleton(){

    }

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

分析：

初始化没有创建，做延迟加载(使用时才初始化，不使用并不会初始化要使用的对象)
构造器一定是pravite
线程不安全
目前此种方式的单例确实满足了懒加载，但对于多线程系统，如果同时存在多个线程，则会导致问题。它将破坏单例模式，两个线程都将获得单例类的不同实例。

2.3 懒汉模式(线程安全)

《重学Java设计模式》

public class Singleton_02 {

    private static Singleton_02 instance;

    private Singleton_02() {
    }

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

}

分析：

此种模式虽然是安全的，但由于把锁加到方法上后，所有的访问都因需要锁占用导致资源的浪费。如果不是特殊情况下，不建议此种方式实现单例模式

2.4 饿汉模式(线程安全)

《重学Java设计模式》

public class Singleton_03 {

    private static Singleton_03 instance = new Singleton_03();

    private Singleton_03() {
    }

    public static Singleton_03 getInstance() {
        return instance;
    }

}

journaldev.com

public class StaticBlockSingleton {

    private static StaticBlockSingleton instance;
    
    private StaticBlockSingleton(){}
    
    //static block initialization for exception handling
    static{
        try{
            instance = new StaticBlockSingleton();
        }catch(Exception e){
            throw new RuntimeException("Exception occured in creating singleton instance");
        }
    }
    
    public static StaticBlockSingleton getInstance(){
        return instance;
    }
}

分析：

在程序启动的时候直接运行加载，后续有外部需要使用的时候获取即可。
但此种方式并不是懒加载，也就是说无论你程序中是否用到这样的类都会在程序启动之初进行创建。
那么这种方式导致的问题就像你下载个游戏软件，可能你游戏地图还没有打开呢，但是程序已经将这些地图全部实例化。到你手机上最明显体验就一开游戏内存满了，手机卡了，需要换了。

2.5 使用类的内部类(线程安全)

public class Singleton_04 {

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

    private Singleton_04() {
    }

    public static Singleton_04 getInstance() {
        return SingletonHolder.instance;
    }

}

分析：

使用类的静态内部类实现的单例模式，既保证了线程安全有保证了懒加载，同时不会因为加锁的方式耗费性能。
这主要是因为JVM虚拟机可以保证多线程并发访问的正确性，也就是一个类的构造方法在多线程环境下可以被正确的加载。
此种方式也是非常推荐使用的一种单例模式

2.6 双重锁校验(线程安全)

public class Singleton_05 {

    private static volatile Singleton_05 instance;

    private Singleton_05() {
    }

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

}

分析：

双重锁的方式是方法级锁的优化，减少了部分获取实例的耗时。
同时这种方式也满足了懒加载。

2.7 CAS 「AtomicReference」(线程安全)

public class Singleton_06 {

    private static final AtomicReference<Singleton_06> INSTANCE = new AtomicReference<Singleton_06>();

    private static Singleton_06 instance;

    private Singleton_06() {
    }

    public static final Singleton_06 getInstance() {
        for (; ; ) {
            Singleton_06 instance = INSTANCE.get();
            if (null != instance) return instance;
            INSTANCE.compareAndSet(null, new Singleton_06());
            return INSTANCE.get();
        }
    }

    public static void main(String[] args) {
        System.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2d
        System.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2d
    }

}

分析：

java并发库提供了很多原子类来支持并发访问的数据安全性；AtomicInteger、AtomicBoolean、AtomicLong、AtomicReference。
AtomicReference<V> 可以封装引用一个V实例，支持并发访问如上的单例方式就是使用了这样的一个特点。
使用CAS的好处就是不需要使用传统的加锁方式保证线程安全，而是依赖于CAS的忙等算法，依赖于底层硬件的实现，来保证线程安全。相对于其他锁的实现没有线程的切换和阻塞也就没有了额外的开销，并且可以支持较大的并发性。
当然CAS也有一个缺点就是忙等，如果一直没有获取到将会处于死循环中。

2.8 插叙：利用反射破坏单例模式

journaldev.com

public class ReflectionSingletonTest {

    public static void main(String[] args) {
        Singleton instanceOne = Singleton.getInstance();
        Singleton instanceTwo = null;
        try {
            Constructor[] constructors = Singleton.class.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                //Below code will destroy the singleton pattern
                constructor.setAccessible(true);
                instanceTwo = (Singleton) constructor.newInstance();
                break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(instanceOne.hashCode());
        System.out.println(instanceTwo.hashCode());
    }

}

当运行上面的测试类时，您会注意到这两个实例的hashCode并不相同，从而破坏了单例模式。反射非常强大，并在许多框架中使用，如Spring和Hibernate。如果要解决该问题可以看看2.9

2.9 Effective Java作者推荐的枚举单例(线程安全)

public enum Singleton_07 {

    INSTANCE;
    public void test(){
        System.out.println("hi~");
    }

}

调用：

@Test
public void test() {
    Singleton_07.INSTANCE.test();

分析：

可以避免单例被反射破坏，因为Java确保任何枚举值只在Java程序中实例化一次。自Java枚举值是全局可访问的，单例值也是可访问的。
Effective Java 作者推荐使用枚举的方式解决单例模式，此种方式可能是平时最少用到的。
这种方式解决了最主要的；线程安全、自由串行化、单一实例。
不支持延迟初始化
这种写法在功能上与共有域方法相近，但是它更简洁，无偿地提供了串行化机制，绝对防止对此实例化，即使是在面对复杂的串行化或者反射攻击的时候。虽然这中方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。
但也要知道此种方式在存在继承场景下是不可用的。

2.10 序列化和Singleton

journaldev.com

有时，在分布式系统中，我们需要在Singleton类中实现可序列化接口，以便将其状态存储在文件系统中，并在以后的某个时间点检索它。下面是一个小的单例类，它也实现了可序列化接口。

import java.io.Serializable;

public class SerializedSingleton implements Serializable{

    private static final long serialVersionUID = -7604766932017737115L;

    private SerializedSingleton(){}
    
    private static class SingletonHelper{
        private static final SerializedSingleton instance = new SerializedSingleton();
    }
    
    public static SerializedSingleton getInstance(){
        return SingletonHelper.instance;
    }
    
}

序列化单例类的问题是，每当我们反序列化它时，它就会创建类的一个新实例。让我们用一个简单的程序来看它。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class SingletonSerializedTest {

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        SerializedSingleton instanceOne = SerializedSingleton.getInstance();
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                "filename.ser"));
        out.writeObject(instanceOne);
        out.close();
        
        //deserailize from file to object
        ObjectInput in = new ObjectInputStream(new FileInputStream(
                "filename.ser"));
        SerializedSingleton instanceTwo = (SerializedSingleton) in.readObject();
        in.close();
        
        System.out.println("instanceOne hashCode="+instanceOne.hashCode());
        System.out.println("instanceTwo hashCode="+instanceTwo.hashCode());
        
    }

}

以上程序的输出为：

instanceOne hashCode=2011117821
instanceTwo hashCode=109647522

因此，它破坏了单例模式，为了克服这种情况，我们所需要做的就是提供readResolve()方法。

protected Object readResolve() {
    return getInstance();
}

在此之后，您将注意到两个实例的hashCode在测试程序中是相同的。

3. 使用示例

菜鸟教程

要求生产唯一序列号。
WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

refactoringguru.cn

Java 核心程序库中有相当多的单例示例：

《重学Java设计模式》

数据库的连接池不会反复创建
spring中一个单例模式bean的生成和使用
在我们平常的代码中需要设置全局的的一些属性保存

4. 总结

《重学Java设计模式》

虽然只是一个很平常的单例模式，但在各种的实现上真的可以看到java的基本功的体现，这里包括了；懒汉、饿汉、线程是否安全、静态类、内部类、加锁、串行化等等。
在平时的开发中如果可以确保此类是全局可用不需要做懒加载，那么直接创建并给外部调用即可。但如果是很多的类，有些需要在用户触发一定的条件后(游戏关卡)才显示，那么一定要用懒加载。线程的安全上可以按需选择。

引流2

Gangbb

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
设计模式学习笔记--单例模式(详细笔记)

文章目录1. 概述2. 代码实现2.1 静态类实现2.2 懒汉式(线程不安全)2.3 懒汉模式(线程安全)2.4 饿汉模式(线程安全)2.5 使用类的内部类(线程安全)2.6 双重锁校验(线程安全)2.7 CAS 「AtomicReference」(线程安全)2.8 插叙：利用反射破坏单例模式2.9 Effective Java作者推荐的枚举单例(线程安全)2.10 序列化和Singleton3. 使用示例4. 总结1. 概述使用背景：《大话设计模式》通常我们可以让一个全局变量使得一个对象被访问，
复制链接

扫一扫

专栏目录