第二章创建模式—单例设计模式

最新推荐文章于 2024-07-27 18:05:15 发布
最新推荐文章于 2024-07-27 18:05:15 发布
阅读量858 收藏
点赞数
分类专栏： 23种设计模式 文章标签： 设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50985215/article/details/130436659
版权

文章目录


单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

  • 所谓的单例模式保证某个类在程序中有且只有一个对象，类比现实生活中的地球类，只有一个地球对象

单例模式的结构

如何控制只有一个对象呢

  • 我们创建一个对象是通过该类的构造方法进行创建对象
  • 我们不能让外部进行创建对象，不然谁都能创建对象，那么就保证不了单例，那么我们的构造方法必须是private修饰，来控制对象的创建，也就是私有的构造方法
  • 外部不能创建对象，那么这个创建唯一的对象的任务也就会在我们单例类来进行实现

怎么设计这个类的内部对象

  • 首先我们知道在外部是创建不了对象的，所以这个对象的类型肯定不能是成员的，必须是静态的，通过类调用
  • 因为成员变量的属性是通过我们的对象进行赋值，我们只有一个对象，如果是成员变量，就先要有对象才能赋值，而赋值了才有那个唯一的对象，就出现了死循环

外部怎么访问

  • 一般属性我们用private进行修饰，为了实现其封装性
  • 直接通过公开的方法获取这个唯一的对象

单例模式的主要有以下角色

  • 单例类。只能创建一个实例的类
  • 访问类。使用单例类

单例模式的实现

单例设计模式分类两种：

  • 饿汉式：类加载就会导致该单实例对象被创建
  • 懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

饿汉式 1：静态变量

public class Singleton {
    //1定义静态成员变量，在类加载时创建
    private static Singleton singleton=new Singleton();
    //2私有化构造方法
    private Singleton(){

    }
    // 3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getSingleton() {
        return singleton;
    }
}
  • 因为singleton是类成员变量，在我 Singleton类加载过程中的初始化过程中进行创建对象赋值，因为只会执行一次，所以是天然的线程安全
  • 缺点：singleton 对象是随着类的加载而创建的，如果该对象很大，却一直没有使用就会造成内存的浪费

饿汉式 2：静态代码块

该方式在成员位置声明 Singleton 类型的静态变量，而对象的创建是在静态代码块中，也是随着类的加载而创建。

public class Singleton {
    //1定义静态成员变量，在类加载时创建
    private static Singleton singleton;
    static {
        singleton=new Singleton();
    }
    //2私有化构造方法
    private Singleton(){
        
    }
    // 3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getSingleton() {
        return singleton;
    }
}

该方式和饿汉式的方式 1 基本一样，所以该方式也存在内存浪费问题。

懒汉式 1：线程不安全

该方式在成员位置声明 Singleton 类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？

当调用 getInstance() 方法获取 Singleton 类的对象的时候才创建 Singleton 类的对象，这样就实现了懒加载效果。

public class Singleton {
    //1定义静态成员变量，在类加载时创建
    private static Singleton singleton;
    //2私有化构造方法
    private Singleton(){

    }
    // 3.提供一个公共的访问方式，让外界获取该对象
    public static Singleton getSingleton(){
        if(singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

测试

public class Client {
    public static void main(String[] args) {
        Thread thread1=new Thread(()->{
            System.out.println(Singleton.getSingleton());
        });
        thread1.start();
        System.out.println(Singleton.getSingleton());
    }
}
//com.lsc.itheima.pattern.singleton.demo3.Singleton@3d075dc0
//com.lsc.itheima.pattern.singleton.demo3.Singleton@6b047ec
  • 发现不是同一个对象，没有实现其单例的效果
  • 为什么不是线程安全的
    • 比如我们的thread1线程调用了getSingleton，进行if(singleton==null)判断，进入了判断体
    • 然后我们的main线程抢占了CPU，进行运行，进行if(singleton==null)判断，因为thread1线程并没有进行创建对象，也进入了判断体
    • 故两个线程各自创建了对应的对象

懒汉式 2：线程安全—方法级上锁

在懒汉式 1 的基础上，使用 synchronized 关键字对getSingleton这个方法进行加锁

public class Singleton {
    //1定义静态成员变量，在类加载时创建
    private static Singleton singleton;
    //2私有化构造方法
    private Singleton(){

    }
    // 3.提供一个公共的访问方式，让外界获取该对象
    public static synchronized Singleton getSingleton(){
        if(singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}
  • 但是该方法的执行效率特别低。
    • 懒汉模式中加锁的问题，对于 getSingleton 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式
  • 注意：其实只有在初始化singleton的时候才会出现线程安全问题，一旦初始化完成就不存在了。

懒汉式 3：双重检查锁🚀

public class Singleton {
    //1定义静态成员变量，在类加载时创建
    private static Singleton singleton;
    //2私有化构造方法
    private Singleton(){

    }
    // 3.提供一个公共的访问方式，让外界获取该对象
    public static  Singleton getSingleton(){
        //第一次判断，如果singleton不为null，不进入抢锁阶段，直接返回实例
        if(singleton==null){
            synchronized (Singleton.class) {
                // 第二次判断,抢占到锁以后再次判断
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

  • 要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。
  • 使用volatile关键字保证单例对象初始化不会被中断，保证其他线程获得的对象一定是初始化完成的对象
    • 比如现在t1线程执行到了初始化的实例对象，正在执行new操作，还没完全结束（但是LazySingleTon！=null），然后t2线程执行到了判断唯一的对象是否为空,对于t2发现不为空，就直接返回了，但是返回的对象是没有完全初始化的，所以需要加volatile，就相当加了一层内存屏障，保证其他线程返回的对象必须等操作完全结束才能执行return语句
public class Singleton {
    //1定义静态成员变量，在类加载时创建
    // 声明Singleton类型的变量,使用volatile保证可见性和有序性
    private static volatile Singleton singleton;
    //2私有化构造方法
    private Singleton(){

    }
    // 3.提供一个公共的访问方式，让外界获取该对象
    public static  Singleton getSingleton(){
        // 第一次判断,如果instance不为null,不需要抢占锁,直接返回对象
        if(singleton==null){
            synchronized (Singleton.class) {
                // 第二次判断,抢占到锁以后再次判断
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

懒汉式 4：静态内部类🚀

静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性/方法被调用时才会被加载，并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

public class Singleton {
    //2私有化构造方法
    private Singleton(){

    }
    // 定义一个静态内部类
    private static class SingletonHolder {
        // 在内部类中声明并初始化外部类的对象
        private static final Singleton singleton = new Singleton();
    }
    // 提供公共的访问方式
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

第一次加载 Singleton 类时不会去初始化 singleton，只有第一次调用 getInstance()，虚拟机加载 SingletonHolder 类并初始化 singleton，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。

静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

饿汉式 3：枚举🚀

首先，枚举方式是饿汉式单例模式，如果不考虑浪费内存空间的问题，这是极力推荐的单例实现模式。

因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式。

枚举的写法非常简单，而且枚举方式是所用单例实现中唯一一种不会被破坏的单例实现模式。

public class SingleTon {
    /**
     * 饿汉式：枚举实现
     */
    public enum Singleton {
        INSTANCE
    }
}

存在的问题

有两种方式可以使上面定义的单例类可以创建多个对象（枚举方式除外），分别是序列化和反射。

枚举方式是利用了 Java 特性实现的单例模式，不会被破坏，其他实现方式都有可能会被破坏

序列化破坏单例

问题演示：下面代码运行结果是false，表明序列化和反序列化破坏了单例设计模式。

public class Client {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
	     writeObject2File();
        Singleton s1 = readObjectFormFile();
        Singleton s2 = readObjectFormFile();
//        System.out.println(s1 == s2); // false
    }
    //从文件读取数据
    public static  Singleton readObjectFormFile() throws IOException, ClassNotFoundException {
        //创建对象输入流对象
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:\\a.txt"));
        //2.读取对象
        Singleton singleton =(Singleton) objectInputStream.readObject();
        //3释放资源
        objectInputStream.close();
        return singleton;
    }
    //向文件写数据
    public static void writeObject2File() throws IOException {
        //1获取Singleton对象
        Singleton singleton = Singleton.getSingleton();
        //创建对象输出流对象
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:\\a.txt"));
        // 3.写对象
        objectOutputStream.writeObject(singleton);
        // 4.释放资源
        objectOutputStream.close();
    }
}

解决方案：在 Singleton 类中添加readResolve()方法。

在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新 new 出来的对象。

/**
 * 双重加锁方式(解决序列化破解单例模式)
 */
public class Singleton implements Serializable {
    //1定义静态成员变量，在类加载时创建
     声明Singleton类型的变量,使用volatile保证可见性和有序性
    private static volatile Singleton singleton;
    //2私有化构造方法
    private Singleton(){

    }
    // 3.提供一个公共的访问方式，让外界获取该对象
    public static  Singleton getSingleton(){
        // 第一次判断,如果instance不为null,不需要抢占锁,直接返回对象
        if(singleton==null){
            synchronized (Singleton.class) {
                // 第二次判断,抢占到锁以后再次判断
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    /**
     * 下面是为了解决序列化反序列化破解单例模式
     * 当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回
     */
    private Object readResolve() {
        return getSingleton();
    }

}

反射破坏单例

public class Client {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
       //1 获取Singleton的字节码对象
        Class<Singleton> singletonClass = Singleton.class;
        //2获取无参构造方法对象
        Constructor<Singleton> declaredConstructor = singletonClass.getDeclaredConstructor();
        //3取消访问检查
        declaredConstructor.setAccessible(true);
        // 4.创建Singleton对象
        Singleton s1 = (Singleton) declaredConstructor.newInstance();
        Singleton s2 = (Singleton) declaredConstructor.newInstance();
        System.out.println(s1 == s2); // false
    }
}

解决方案：当通过反射方式调用构造方法进行创建时，直接抛异常

public class Singleton {
    //1定义静态成员变量，在类加载时创建
     声明Singleton类型的变量,使用volatile保证可见性和有序性
    private static volatile Singleton singleton;
    private static boolean flag = false;
    //2私有化构造方法
    // 私有构造方法
    private Singleton() {
        synchronized (Singleton.class) {
            // 如果是true,说明非第一次访问,直接抛一个异常,如果是false,说明第一次访问
            if (flag) {
                throw new RuntimeException("不能创建多个对象");
            }
            flag = true;
        }
    }
    // 3.提供一个公共的访问方式，让外界获取该对象
    public static  Singleton getSingleton(){
        // 第一次判断,如果instance不为null,不需要抢占锁,直接返回对象
        if(singleton==null){
            synchronized (Singleton.class) {
                // 第二次判断,抢占到锁以后再次判断
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

JDK 源码 - Runtime 类

Runtime 类使用的就是单例设计模式。

源码查看：下面是 Runtime 类的源码，是静态变量方式的饿汉单例模式。

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    ...
}


/**
 *  RuntimeDemo
 */
public class RuntimeDemo {
    public static void main(String[] args) throws IOException {
        // 获取Runtime类的对象
        Runtime runtime = Runtime.getRuntime();
        // 调用runtime的方法exec,参数要的是一个命令
        Process process = runtime.exec("ifconfig");
        // 调用process对象的获取输入流的方法
        InputStream is =  process.getInputStream();
        byte[] arr = new byte[1024 * 1024 * 100];
        // 读取数据
        int len = is.read(arr); // 返回读到的字节的个数
        // 将字节数组转换为字符串输出到控制台
        System.out.println(new String(arr, 0, len, "GBK"));
    }
}
库里不会投三分
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第二章：对象创建型模式之单例模式
一只猫的博客
02-06 188
确保一个类在整个应用程序的生命周期中只有一个实例，并提供一个全局访问点来访问该实例。根据单例模式的定义，单例模式一个类只能有一个实例。这个类必须自行创建自己的实例。它必须向其他所有对象提供这一唯一实例。
《C++ 设计模式原理与实战大全》第二章
09-20
《C++ 设计模式原理与实战大全》第二章深入探讨了这一主题，帮助开发者掌握如何在C++中有效地应用设计模式。 首先，设计模式是软件工程中的经验总结，它提供了一套通用的解决方案模板，用于处理特定的编程情境。C++...
软件设计模式--第二章 创建型模式-- 单例模式
ljn1046016768的博客
04-25 398
软件设计模式 创建型模式 单例模式
设计模式 第二章 单例模式
wpwdm159357的博客
11-03 142
# 设计模式 第一章 基本原则 文章目录# 设计模式 第一章 基本原则前言一、饿汉式静态常量1.优点2.缺点3.代码示例二、饿汉式静态代码块1.优点2.缺点3.代码示例三、懒汉式线程不安全1.优点2.缺点3.代码示例四、懒汉式线程安全1.优点2.缺点3.代码示例五、懒汉式线程安全同步代码块1.优点2.缺点3.代码示例六、双重检查1.优点2.缺点3.代码示例七、静态内部类1.优点2.代码示例八、枚举1.优点2.代码示例 前言 单例模式为创建者模式的一种，就是采取一定的方法保证对一个类只能存在一个对象实例。并且
【从零开始学设计模式】第二章_单例模式
踢桃的成长之路
02-04 1831
单例模式：确保一个类中在内存中只能存在一个实例对象
Java设计模式（第五章：单例模式）
桃花er的博客
01-19 453
第五章：单例设计模式 5.1 单例设计模式介绍 单例设计模式：就是采取一定的方法保证在整个的软件系统种，对某个类只能存在一个对象实例，并且该类对系统只提供一个取得其对象实例的方法（静态方法）。 5.2 单例设计模式要点： 5.2.1 第一点：某个类只能有一个实例 某个类只能有一个实例 ------> 构造器私有化 5.2.2 第二点：它必须自行创建这个实例 它必须自行创建这个实例 ------> 含有一个该类的静态变量来保存这个唯一的实例 5.2.3 第三点：它必须自行向整个系统提供这个
单例设计模式(创建型)
MathYounG的博客
07-11 278
文章目录设计模式之单例设计模式一、什么是单例设计模式？二、单例设计模式的优缺点三、单例设计模式的使用四、单例设计模式分类五、单例模式思想的传递过程六、懒加载（Lazy Load）七、单例设计模式的线程安全问题八、单例模式分类剖析5.1 饿汉式单例模式（推荐）5.2 普通懒汉式单例模式5.3 同步锁懒汉式单例模式5.4 同步代码块懒汉式单例模式5.5 双重校验锁/双检锁单例模式（推荐）5.6 静态内部类/登记式单例模式（推荐）5.7 枚举单例模式九、解决多种破坏单例模式原则的方法9.1 反射破坏单例模式原则剖
java设计模式 第三章:单例模式
Asparrow的博客
12-05 1071
单例模式面试必会,设计模式入门
【Java设计模式】创建型设计模式-单例模式（二）
古采尼的博客
03-18 768
单例模式适用于需要频繁创建和销毁且消耗时间较长，耗费资源过多，但又是频繁使用的对象（重量级对象）。例如：工具类对象、web开发中的必须用到的对象（servlet对象）、用于操作数据库和文件的对象（数据源对象、session工厂对象等）
大话设计模式 第二十一章 单例模式
nailsoul的专栏
04-01 85
单例模式 一个类只有一个实例 且提供一个全局访问点 单例和全局工具类区别 单例有状态 链式调用idea不警告 可以继承父类实现接口使用多态 @Test public class SingleTest { public void testSingle(){ Object instance = Single.RecommendSafeSingle.getInstance(); Object instance2 = Single.RecommendSafeSingl
设计模式：解锁代码世界的秘密宝藏
07-13
#### 第二章：工厂模式——生产者的智慧 **概念解析**：工厂模式提供了一个创建对象的接口，但允许子类决定实例化哪一个类。这种模式将对象的创建封装在一个类中，使得系统可以在不知道具体类的情况下创建产品。...
C++Qt设计模式第二版部分程序
09-29
本压缩包包含了"C++Qt设计模式第二版"的第八章和第九章的部分源码，这些章节可能涉及了具体的设计模式实现以及如何在Qt框架下应用它们。 首先，让我们来探讨一下设计模式的基本概念。设计模式是解决软件设计中常见...
基于STM32F103的FreeRTOS系列（一）·单片机设计模式介绍·裸机程序的设计模式
时光の尘的博客
07-22 1225
裸机程序的设计模式可以分为：轮询、前后台、定时器驱动、基于状态机。：周期性地查询各个模块或函数的状态，适用于简单且响应时间要求不高的系统，但无法有效解决复杂函数之间的相互影响问题。：通过将关键任务放在前台处理，而非关键任务放在后台，以确保关键任务的优先执行。这种方式对优先级管理有效，但复杂函数之间的相互影响仍可能存在。：通过定时器周期性地触发任务执行，适合需要定期执行任务的场景，但不能解决函数间相互影响的问题。：将系统的各种状态和状态转移定义清晰，通过状态切换来控制系统行为。
设计模式-单例模式
最新发布
weixin_51722520的博客
07-27 166
单例设计模式
C# 设计模式分类
語衣的个人博客
07-23 988
创建型模式主要关注对象的创建过程，包括如何实例化对象，并隐藏实例化的细节。结构型模式主要关注类和对象的组合，以形成更大的结构。行为型模式主要关注对象之间的通信和职责分配。
js 优雅的实现模板方法设计模式
qq_43985303的博客
07-24 346
在JavaScript中，优雅地实现模板方法设计模式通常意味着我们要遵循一些最佳实践，如清晰地定义算法的骨架（模板方法），并确保子类能够灵活地扩展或修改这些算法中的特定步骤。此外，由于JavaScript的类和继承是基于原型的，因此这种实现方式也充分利用了JavaScript的继承机制，使得代码更加符合JavaScript的编程习惯。优雅性：通过提供默认实现，避免了在子类中必须实现所有方法的强制性要求，从而提高了代码的优雅性。灵活性：子类可以自由地选择覆盖哪些钩子方法，以及覆盖后的行为是什么。
6.3 面向对象技术-设计模式
m0_38066007的博客
07-26 505
设计模式
后端面试题日常练-day06 【Java基础】
qq_44640575的博客
07-25 595
希望这些选择题能够帮助您进行后端面试的准备，答案在文末在Java中，以下哪个关键字用于表示类之间的关联性，表明一个类包含另一个类的对象？a) includeb) containJava中的方法重写（Override）和方法重载（Overload）有何区别？a) 重写是子类重新定义父类方法，重载是在同一类中定义多个方法b) 重写是在同一类中定义多个方法，重载是子类重新定义父类方法c) 重写和重载的概念相同，在Java中没有区别。
Java设计模式详解：23种模式实践指南
本书共有二十六章节，涵盖了二十三个设计模式，包括策略模式、代理模式、单例模式、多例模式、工厂方法模式、抽象工厂模式、门面模式、适配器模式、模板方法模式、建造者模式、桥梁模式、命令模式、装饰模式、迭代器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

库里不会投三分

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值