1. Toy模板网首页
  2. > Toy博客

Java 设计模式——单例模式

7月前 作者：代码星辰 分类：Toy博客 阅读(46) 违法举报

这篇具有很好参考价值的文章主要介绍了Java 设计模式——单例模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1.概述

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

（2）单例模式的目的是限制一个类的实例数量，并提供全局访问点以方便其他组件使用。它通常在需要共享资源、管理全局状态或限制某个组件数量的情况下使用。然而，单例模式也有一些缺点，例如增加了代码的耦合性和可扩展性的限制，因此在使用时需要权衡其利弊。

（3）单例模式的主要有单例类和访问类这两个角色：

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

2.实现

单例模式分类两种：饿汉式和懒汉式。

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

2.1.饿汉式

2.1.1.静态变量

package com.itheima.patterns.singleton.hungryman1;

//饿汉式
public class Singleton{
    
    //私有构造方法
    private Singleton(){}
    
    //静态变量创建类的对象
    private static Singleton instance = new Singleton();

    //对外提供静态方法获取该对象
    public static Singleton getInstance(){
        return instance;
    }
}

说明： 方式一在成员位置声明 Singleton 类型的静态变量，并创建 Singleton 类的对象 instance。instance 对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

2.1.2.静态代码块

package com.itheima.patterns.singleton.hungryman2;

public class Singleton{
    
    //私有构造方法
    private Singleton(){}
    
    //在静态代码块中进行创建
    private static Singleton instance;
    static {
        instance = new Singleton();
    }
    
    //对外提供静态方法获取该对象
    public static Singleton getInstance(){
        return instance;
    }
}

说明：方式二在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是随着类的加载而创建。所以和方式一基本一样，也存在内存浪费问题。

2.1.3.枚举方式

enum Singleton {
    //INSTANCE;

    INSTANCE("Tom", 21);

    // 添加其他成员变量
    private String name;
    private int age;

    Singleton(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return this.age;
    }

    // 添加其他方法
    public void sayHello() {
        System.out.println("Hello, I'm " + name + ", " + age + " years old.");
    }
}

说明：枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。测试代码如下：
Client.java

public class Client {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println("instance1 == instance2 的结果为: " + (instance1 == instance2));   // true

        System.out.println(instance1.getAge());
        instance1.setAge(50);
        System.out.println(instance2.getAge());
    }
}

输出结果如下：

instance1 == instance2 的结果为: true
21
50

2.2.懒汉式

2.2.1.synchronized 线程安全

package com.itheima.patterns.singleton.Lazyman;

public class Singleton{
    
    //私有构造方法
    private Singleton(){}
    
    //声明 Singleton 类型的变量 instance，并未进行赋值
    private static Singleton instance;
    
    //使用关键字 synchronized 的目的在于保证线程安全
    public static synchronized Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

说明：该方式实现了懒加载效果，同时又解决了线程安全问题。但是在 getInstance() 方法上添加了 synchronized 关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化 instance 的时候才会出现线程安全问题，一旦初始化完成就不存在了。

2.2.2.双重检查锁

public class Singleton {
    
    //私有构造方法
    private Singleton(){}
    
    //声明 Singleton 类型的变量 instance，并未进行赋值
    private static volatile Singleton instance;
    
    public static Singleton getInstance(){
        //第一次检查，若 instance 不为 null，则不进入抢锁阶段，直接返回实际值即可
        if (instance == null) {
            synchronized(Singleton.class){
                //第二次检查，得到锁之后再次判断 instance 是否为空
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

（1）双重检验锁 (Double-Checked Locking) 是一种在多线程环境下实现单例模式的优化方式。其主要原理如下：

  • 首先检查实例是否已经被创建，如果已经创建，则直接返回已经创建的实例，不再进入同步代码块，提高性能。
  • 如果实例尚未创建，则进入同步代码块，在同步代码块内再次检查实例是否已经被创建。
  • 在同步代码块内部进行第二次检查时，由于进入同步块的只有一个线程，其他线程处于等待状态，避免了多个线程同时进入同步代码块创建实例。
  • 在第二次检查时，如果实例尚未创建，则创建实例，并将实例赋值给成员变量，确保只有一个实例被创建。
  • 最后，释放锁，并返回实例。

（2）这种方式结合了懒加载和线程安全的特点，在第一次调用时才创建实例，在多线程环境下确保只有一个实例被创建。双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题。

（3）在双重检查锁的实现方式中，如果没有使用 volatile 关键字，可能会出现指令重排序的问题。具体来说，当一个线程进入第一个 if 判断时，如果实例还未被创建，那么它会获取锁并创建实例。但是由于指令重排序的影响，实例的初始化可能会在获取锁之前被重排序到锁的后面，这就导致其他线程在第二个 if 判断中认为实例已经创建，从而返回一个未完全初始化的实例。

（4）通过使用 volatile 关键字修饰 instance 变量，可以保证在多线程环境下对 instance 的读取和写入操作都是有序的，避免了指令重排序问题，并且保证了其他线程能够正确地看到已经完全初始化的实例。

相关知识点：
Java 并发编程面试题——synchronized 与 volatile

2.2.3.静态内部类方式

package com.itheima.patterns.singleton.lazyman3;

public class Singleton {
    
    //私有构造方法
    private Singleton(){}
    
    //静态内部类
    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }
    
    //对外提供静态方法获取该对象
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

（1）第一次加载 Singleton 类时不会去初始化 INSTANCE，只有第一次调用 getInstance() 时，虚拟机才加载 SingletonHolder，并初始化 INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。总之，静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

（2）静态内部类实现的单例可以做到线程安全且可延迟加载的原因如下：

  • 线程安全：静态内部类的加载是在第一次使用时进行的，并且由 Java 虚拟机来保证类加载的线程安全性。在类加载过程中，虚拟机会对类进行初始化，并且只会进行一次，这样就避免了多线程环境下的竞争条件。因此，通过静态内部类实现的单例可以在多线程环境下安全地被多个线程共享。
  • 可延迟加载：静态内部类的初始化是在第一次使用时进行的，即在调用 getInstance 方法时才会加载内部类。这样可以延迟单例对象的初始化过程，只有在需要使用到单例对象时才进行初始化。这对于资源消耗较大的对象或需求延迟加载的场景特别有用，可以节省内存空间和系统资源，并提高应用的启动性能。

3.破坏单例模式

破坏单例模式演示（序列化反序列化和反射）

3.1.序列化反序列化

package com.itheima.patterns.singleton.problem1;

import java.io.Serializable;

public class Singleton implements Serializable {
    //私有构造方法
    private Singleton() {}
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

package com.itheima.patterns.singleton.problem1;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;


public class Client {
    public static void main(String[] args) throws Exception {
        writeObject2File();
        readObjectFromFile();
        readObjectFromFile();
    }
    
    //从文件读取数据（对象）
    public static void readObjectFromFile() throws Exception {
        //1.创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\testData\\a.txt"));
        //2.读取对象
        Singleton instance = (Singleton) ois.readObject();        
        System.out.println(instance);        
        //释放资源
        ois.close();
    }
    
    //向文件中写数据（对象）
    public static void writeObject2File() throws Exception {
        //1.获取Singleton对象
        Singleton instance = Singleton.getInstance();
        //2.创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\testData\\a.txt"));
        //3.写对象
        oos.writeObject(instance);
        //4.释放资源
        oos.close();
    }
}

Java 设计模式——单例模式,Java 设计模式,java,设计模式,单例模式

3.2.反射

public class Singleton {
	//私有构造方法
	private Singleton() {}
	private static volatile Singleton instance;
	//对外提供静态方法获取该对象
	public static Singleton getInstance() {
		if(instance != null) {
			return instance;
		}
		synchronized (Singleton.class) {
			if(instance != null) {
				return instance;
			}
			instance = new Singleton();
			return instance;
		}
	}
}

import java.lang.reflect.Constructor;

public class Client {
    public static void main(String[] args) throws Exception {
        //获取 Singleton 类的字节码对象
        Class clazz = Singleton.class;
        //获取 Singleton 类的私有无参构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor();
        //取消访问检查
        constructor.setAccessible(true);
        //创建 Singleton 类的对象 s1
        Singleton s1 = (Singleton) constructor.newInstance();
        //创建 Singleton 类的对象 s2
        Singleton s2 = (Singleton) constructor.newInstance();
        //判断通过反射创建的两个 Singleton 对象是否是同一个对象
        System.out.println(s1 == s2);  // false
    }
}

4.问题解决

（1）序列化、反序列化方式破坏单例模式的解决方法
在 Singleton 类中添加 readResolve() 方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新 new 出来的对象。

import java.io.Serializable;

public class Singleton implements Serializable {
    //私有构造方法
    private Singleton() {}
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    
    //解决序列化反序列化破解单例模式
    private Object readResolve() {
        return SingletonHolder.INSTANCE;
    }
}

具体的深入分析可以参考单例、序列化和 readResolve() 方法。

（2）反射方式破解单例的解决方法
当通过反射方式调用构造方法创建对象时，直接抛异常，不运行此种操作。

import java.io.Serializable;

public class Singleton implements Serializable {
    
    private static boolean flag = false;
    
    //私有构造方法
    private Singleton() {
        synchronized (Singleton.class){
            //若 flag 的值为 true，说明不是第一次访问，直接抛一个异常
            if (flag){
                throw new RuntimeException("不能创建多个对象！");
            }
            flag = true;
        }
    }
    
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    //对外提供静态方法获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    
    //解决序列化反序列化破解单例模式
    private Object readResolve() {
        return SingletonHolder.INSTANCE;
    }
}

但是上面的操作也不一定安全，因为可以通过反射的方式来修改 flag，最安全的方式应该是使用枚举方式来创建单例对象，其原因在于 JDK 底层在通过反射创建对象时，会检查对象类型是否为枚举类型，如果是，则会抛出 IllegalArgumentException 异常，从而创建对象失败，这样做的目的在于保证枚举对象的单例性。具体相关源码如下所示：

@CallerSensitive
public final class Constructor<T> extends Executable {

	//...
	
    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        //检查给定的 clazz 对象的修饰符中是否包含枚举类型的标志位，以确定其是否表示一个枚举类型
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }
}

5.优缺点

（1）单例模式是一种只允许创建一个实例的设计模式。它的主要优点是：

  • 独一无二的实例：单例模式确保在整个应用程序中只有一个实例存在。这在某些情况下是非常有用的，例如需要共享资源或限制系统中某个组件的数量。
  • 全局访问点：由于单例实例是全局可访问的，所以可以方便地从任何地方访问它。这对于需要频繁访问单例实例的组件非常有用，避免了传递实例的麻烦。

（2）然而，单例模式也有一些缺点：

  • 耦合性：使用单例模式可能导致代码中的紧耦合，因为它引入了全局状态。这会使代码在可测试性和可维护性方面变得更加困难，因为任何依赖单例实例的组件都与该实例紧密耦合。
  • 难以扩展：由于单例模式只允许存在一个实例，因此在需要扩展功能时可能会遇到限制。如果需要创建多个实例来满足新的需求，则需要修改单例类的实现。
  • 隐藏依赖关系：使用单例模式可能会隐藏代码中的依赖关系。由于可以从任何地方访问单例实例，组件之间的依赖关系可能不明显，导致代码更难以理解和维护。

6.应用场景

（1）单例模式可以应用于许多场景，其中一些常见的应用场景包括：

  • 日志记录器：在应用程序中，通常只需要一个日志记录器来记录系统的日志信息。使用单例模式可以确保只有一个日志记录器实例存在，并且可以从任何地方方便地访问它。
  • 数据库连接池：在需要频繁访问数据库的应用程序中，可以使用单例模式来管理数据库连接池。通过保持只有一个数据库连接池实例存在，可以避免创建过多的数据库连接，提高性能和资源利用率。
  • 配置信息管理器：在应用程序中，通常需要加载和访问配置信息。使用单例模式可以创建一个全局的配置信息管理器，用于加载和提供应用程序所需的配置信息，避免重复加载和管理多个实例。
  • 线程池：在需要管理线程执行的应用程序中，可以使用单例模式来创建并管理线程池。通过保持只有一个线程池实例存在，可以方便地分配和管理线程，提高并发性能。
  • GUI 应用程序中的窗口管理器：在 GUI 应用程序中，通常需要管理窗口的创建、显示和销毁。使用单例模式可以创建一个全局的窗口管理器，用于管理应用程序中的所有窗口。

（2）这只是一些常见的应用场景，实际上，任何需要全局访问点和只允许存在一个实例的情况都可以考虑使用单例模式。但请注意，在使用单例模式时需要慎重考虑其优缺点，并确保它满足设计需求。

7.JDK 源码解析——Runtime 类

（1）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() {}
	...
}

从上面源代码中可以看出 Runtime 类使用的是饿汉式（静态属性）方式来实现单例模式的。

（2）使用 Runtime 类文章来源地址https://www.toymoban.com/news/detail-546779.html

import java.io.IOException;
import java.io.InputStream;

public class RunTimeDemo {
    
    public static void main(String[] args) throws IOException {
        //获取RunTime类对象
        Runtime runtime = Runtime.getRuntime();
    
        System.out.println("JVM 空闲内存 =" + runtime.freeMemory() / (1024*1024) + "M");
        System.out.println("JVM 总内存 =" + runtime.totalMemory() / (1024*1024) + "M");
        System.out.println("JVM 可用最大内存 =" + runtime.maxMemory() / (1024*1024) + "M");
        
        //调用 runtime 的方法 exec，参数为一个命令
        Process process = runtime.exec("ipconfig");
        //调用 process 对象的获取输入流的方法
        InputStream is = process.getInputStream();
        byte[] arr = new byte[1024 * 1024 * 100];
        int length = is.read(arr);
        System.out.println(new String(arr,0,length, "GBK"));
    }
}

到了这里，关于Java 设计模式——单例模式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • java设计模式-单例

    单例模式是一种创建型设计模式，它可以保证一个类只有一个实例，并提供全局访问点。单例模式在实际开发中经常使用，可以避免多个实例引起的资源浪费和同步问题。常见的java实现方式有多种。 饿汉式单例模式是指在类加载时就创建了单例对象，因此在调用时不需要再

    2024年01月18日
    浏览(39)

  • Java设计模式---单例 工厂 代理模式

    单例模式是设计模式中的一种，属于创建型模式。在软件工程中，单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式常用于那些需要频繁实例化然后引用，且创建新实例的开销较大的类，例如数据库连接池、缓存管理等。 意图 ：保证一个类仅有一个实例

    2024年01月24日
    浏览(36)
  • 设计模式篇(Java)：单例模式

    设计模式篇(Java)：单例模式

    上一篇：设计模式篇(Java)：前言(UML类图、七大原则) 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 构造器私有化 (防止 new ) 类的内部创建对象 向外暴露一个静

    2024年02月11日
    浏览(44)
  • Java——单例设计模式

    Java——单例设计模式

    设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱、“套路”。 经典的设计模式共有23种。每个设计模式均是特定环境下特定问题的

    2024年02月11日
    浏览(32)
  • 【JAVA】Java 中什么叫单例设计模式？请用 Java 写出线程安全的单例模式

    【JAVA】Java 中什么叫单例设计模式？请用 Java 写出线程安全的单例模式

    🍎 个人博客： 个人主页 🏆 个人专栏： JAVA ⛳️   功不唐捐，玉汝于成 目录 前言 正文 懒汉式（Lazy Initialization）： 双重检查锁定（Double-Checked Locking）： 结语 我的其他博客 在软件设计中，单例设计模式是一种重要的设计思想，它确保了一个类只有一个实例，并提供了一

    2024年01月15日
    浏览(34)
  • Java设计模式之单例模式

    Java设计模式之单例模式

    定义：保证一个类仅有一个实例，并提供一个全局访问点 类型：创建型 想确保任何情况下都绝对只有一个实例 例如：线程池，数据库连接池一般都为单例模式 单例模式优点 在内存中只有一个实例，减少内存开销 可以避免对资源的多重占用 设置全局访问点，严格控制访问

    2024年02月02日
    浏览(54)
  • Java设计模式（八）— 单例模式3

    Java设计模式（八）— 单例模式3

    单例模式之静态内部类 单例模式之枚举方式 单例模式之JDK源码分析 Hello，小伙伴们，欢迎来到柚子的博客~让我们一起成长吧o(￣▽￣)ブ 提示：以下是本篇文章正文内容，下面案例可供参考 代码如下（示例）： 类被装载的时候，类里面的静态内部类也是会被装载的，而且线

    2024年02月09日
    浏览(36)

  • java设计模式-单例模式（Singleton）

    单例模式（Singleton）就是一个类只能有一个实例，自行实例化，并向系统提供这一实例，这个类就是单例类。单例模式的特点： 一个类只能有一个实例； 单例类自己实例化； 单例类给其它对象提供这个单一实例。 资源管理类经常被设计为单例模式，例如管理属性文件的类。

    2024年02月15日
    浏览(29)

  • Java与设计模式（4）：单例模式

    单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供全局访问点来访问该实例。 在单例模式中，类的构造函数被私有化，从而禁止外部直接实例化该类。通过一个静态方法或静态变量来控制类的实例化过程，并返回同一个实例。 单例模式的特点包括： 单一

    2024年02月12日
    浏览(53)
  • 03-JAVA设计模式-单例模式详解

    03-JAVA设计模式-单例模式详解

    单例模式（Singleton Pattern）是设计模式中的一种，它确保一个类仅有一个实例，并提供一个全局访问点来访问该实例。这种设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 单例模式的应用场景十分广泛，主要涉及需要频繁使用某个对象而又不想重复创建的情况

    2024年04月13日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包