首页 > 资讯 > 后端开发 > Python >Java23种设计模式中的单例模式你了解吗

266

分享到

Java23种设计模式中的单例模式你了解吗

2024-04-02 19:04:59 266人浏览薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

目录1、定义2、适用场景3、常见写法4、如何防止单例被破坏1.多线程破坏单例以及解决方法2.反射破坏单例以及解决方法3.序列化破坏单例以及解决方法5、优缺点6、总结1、定义单例模式

1、定义

单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
隐藏其所有的构造方法。
属于创建型模式。

2、适用场景

确保任何情况下都绝对只有一个实例。

3、常见写法

第一种：饿汉式单例：在单例类首次加载时就创建实例


public class HungrySingleton {
    private static final HungrySingleton INSTANCE = new HungrySingleton();
    
    private HungrySingleton() {
    }
    
    public static HungrySingleton getInstance() {
        return INSTANCE;
    }
}

饿汉式单例静态代码块写法：


public class HungryStaticSingleton {
    private static final HungryStaticSingleton INSTANCE;
    
    static {
        INSTANCE = new HungryStaticSingleton();
    }
    
    private HungryStaticSingleton() {
    }
    
    public static HungryStaticSingleton getInstance() {
        return INSTANCE;
    }
}

第二种：懒汉式单例：被外部类调用时才创建实例


public class LazySingleton {
    private static LazySingleton INSTANCE = null;
    
    private LazySingleton() {
    }
    
    public static LazySingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }
}

懒汉式单例静态匿名内部类写法(性能最优)：


public class LazyInnerClazzSingleton implements Serializable {
    
    private LazyInnerClazzSingleton() {
    }
    
    public static final LazyInnerClazzSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();
    }
}

第三种：注册式单例：将每一个实例都缓存到统一的容器中，使用唯一标识获取实例

注册式单例枚举写法：


public enum EnumSingleton {
    INSTANCE;
    
    private Object data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

Spring中常见的注册式单例写法：


public class ContainerSingleton {
    
    private static Map<String, Object> container = new ConcurrentHashMap<>();
    private ContainerSingleton() {
    }
    public static Object getBean(String clazzName) {
        // 加synchronized代码块保证线程安全
        synchronized (container) {
            if (!container.containsKey(clazzName)) {
                Object object = null;
                try {
                    object = Class.forName(clazzName).newInstance();
                    container.put(clazzName, object);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return object;
            }
            return container.get(clazzName);
        }
    }
}

第四种：ThreadLocal线程单例：保证线程内部的全局唯一，且天生线程安全


public class ThreadLocalSingleton {
    public static final ThreadLocal<ThreadLocalSingleton> THREAD_LOCAL = new ThreadLocal<ThreadLocalSingleton>() {
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };
    private ThreadLocalSingleton() {
    }
    public static ThreadLocalSingleton getInstance() {
        return THREAD_LOCAL.get();
    }
}

4、如何防止单例被破坏

1.多线程破坏单例以及解决方法

以懒汉式单例LazySingleton为例：

首先写一个线程实现类，如下：

import com.hzg.study.design.pattern.singleton.lazy.LazySingleton;

public class ExecutorThread implements Runnable {
    @Override
    public void run() {
        LazySingleton instance = LazySingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + instance);
    }
}

main方法测试：

public class LazySingletonTest {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new ExecutorThread());
        thread1.start();
        Thread thread2 = new Thread(new ExecutorThread());
        thread2.start();
        System.out.println("----------------------------------------");
    }
}

测试结果：显然出现了两个不同的实例

解决方法1：加synchronized关键字修饰getInstance方法

public class LazySingleton {
    private static LazySingleton INSTANCE = null;
    
    private LazySingleton() {
    }
    
    public static synchronized LazySingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }
}

解决方法2：双重检查锁DoubleCheck


public class LazyDoubleCheckSingleton {
    
    private volatile static LazyDoubleCheckSingleton INSTANCE = null;
    
    private LazyDoubleCheckSingleton() {
    }
    
    public static LazyDoubleCheckSingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new LazyDoubleCheckSingleton();
                }
            }
        }
        return INSTANCE;
    }
}

2.反射破坏单例以及解决方法

以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：

main方法测试：

public class LazyInnerClazzSingletonTest {
    public static void main(String[] args) {
        try {
            Class<LazyInnerClazzSingleton> aClazz = LazyInnerClazzSingleton.class;
            Constructor<LazyInnerClazzSingleton> declaredConstructor = aClazz.getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);
            LazyInnerClazzSingleton instance1 = declaredConstructor.newInstance();
            LazyInnerClazzSingleton instance2 = LazyInnerClazzSingleton.getInstance();
            System.out.println(instance1);
            System.out.println(instance2);
            System.out.println(instance1 == instance2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试结果：构建了两个不同的实例

解决方法：在构造器中增加如下if判断

public class LazyInnerClazzSingleton implements Serializable {
    
    private LazyInnerClazzSingleton() {
        if (null != LazyHolder.INSTANCE) {
            throw new RuntimeException("不允许构建多个实例");
        }
    }
    
    public static final LazyInnerClazzSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();
    }
}

再次测试：

3.序列化破坏单例以及解决方法

以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：注意必须先实现序列化接口Serializable

main方法测试：

    public static void main(String[] args) {
        LazyInnerClazzSingleton instance1 = LazyInnerClazzSingleton.getInstance();
        LazyInnerClazzSingleton instance2 = null;
        try (
                FileOutputStream fileOutputStream = new FileOutputStream("LazyInnerClazzSingleton.obj");
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
                FileInputStream fileInputStream = new FileInputStream("LazyInnerClazzSingleton.obj");
                ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        ) {
            // 序列化
            objectOutputStream.writeObject(instance1);
            objectOutputStream.flush();
            // 反序列化
            instance2 = (LazyInnerClazzSingleton) objectInputStream.readObject();
            System.out.println(instance1);
            System.out.println(instance2);
            System.out.println(instance1 == instance2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

测试结果：构建了两个不同的实例

解决方法：新增readResolve方法

public class LazyInnerClazzSingleton implements Serializable {
    
    private LazyInnerClazzSingleton() {
        if (null != LazyHolder.INSTANCE) {
            throw new RuntimeException("不允许构建多个实例");
        }
    }
    
    public static final LazyInnerClazzSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();
    }
    
    private Object readResolve() {
        return LazyHolder.INSTANCE;
    }
}

5、优缺点

优点：

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

缺点：

没有接口，扩展困难。
如果要扩展单例对象，只有修改代码，没有其他途径。
不符合开闭原则

6、总结

1、私有化构造器

2、保证线程安全

3、延迟加载

4、防止序列化和反序列化破坏单例

5、防御反射攻击单例

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注编程网的更多内容!

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java23种设计模式中的单例模式你了解吗

本文链接: https://www.lsjlt.com/news/140120.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

Java23种设计模式中的单例模式你了解吗

目录1、定义2、适用场景3、常见写法4、如何防止单例被破坏1.多线程破坏单例以及解决方法2.反射破坏单例以及解决方法3.序列化破坏单例以及解决方法5、优缺点6、总结1、定义单例模式...

99+

2024-04-02
C++设计模式中的桥模式你了解吗

目录单一职责模式:典型模式Bridge动机（Motivation）模式定义结构要点总结cpp总结单一职责模式: 在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着...

99+

2024-04-02
JAVA设计模式---单例模式你知道吗

目录单例模式的介绍单例模式实现的八种方式饿汉式静态常量静态代码块懒汉式线程不安全的写法线程安全，同步锁—效率低，不推荐线程安全，同步代码块—无法解决线程安全问题，不推荐双重检查—解决...

99+

2024-04-02
python设计模式之单例模式你了解多少

目录单例模式概念单例模式使用场景python实现单例模式总结单例模式概念单例模式：“保证一个类仅有一个实例，并提供一个访问它的在这里插入代码片全局访问点。单例模式会...

99+

2024-04-02
Python设计模式中的状态模式你了解吗

目录状态模式应用场景代码示例总结状态模式状态模式，当对象的内部状态发生了改变的时候，允许对象执行不同的流程。优点：封装了状态转换规则。枚举了可能的状态，在枚举状态之前需要确定...

99+

2024-04-02
JAVA设计模式中的策略模式你了解吗

目录策略模式策略模式是什么策略模式的使用场景策略模式实践总结策略模式世界上本没有模式; 一些程序老鸟在长时间的编程工作总结出高效的代码写法被后世推崇; 并整理出固定的写法规范,这个...

99+

2024-04-02
JAVA设计模式---原型模式你了解吗

目录介绍角色Java语言提供的clone()方法代码演示—克隆羊结论深浅拷贝深浅拷贝探讨实现深克隆的方式一：手动对引用对象进行克隆实现深克隆的方式二：序列化原型模式对单例模式的...

99+

2024-04-02
关于Java23种设计模式的有趣见解

关于Java23种设计模式的有趣见解...

99+

2023-06-03
理解JavaScript设计模式中的单例模式

单例模式（Singleton Pattern）是最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。单例模式涉及到一个单一的类，该类负责创建自己...

99+

2024-04-02
JavaScript中的设计模式单例模式

目录1、什么是设计模式2、设计模式五大设计原则（SOLID）3、为什么需要设计模式？4、单例模式前言：设计模式在我们编程中是十分重要的！设计模式（Design pattern）...

99+

2024-04-02
Java设计模式-单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供...

99+

2023-06-05
【python 设计模式】单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。比如，某个服务器程序的配置信息存放在一个文件中...

99+

2023-01-31

模式 python
Python设计模式——单例模式

一、单例模式理论单例模式：保证某一个类只有一个实例，而且在全局只有一个访问点优点： 1、由于单例模式要求在全局内只有一个实例，因而可以节省比较多的内存空间 2、全局只有一个接入点，可以更好地进行数据同步控制，避免多重占用...

99+

2023-01-31

模式 Python
Android设计模式之单例模式详解

单例模式一个类只有一个实例，并且可以全局访问使用应用场景如账户管理类，数据库操作类等（某个对象频繁被访问使用）常用方式饿汉式懒汉式同步加锁DCL双重加锁验证静态内部类枚举单例饿汉式加载类的同时立即进行初始化操作，对资源消耗很大public ...

99+

2023-05-30

android 设计模式单例模式
C++设计模式之单例模式详解

目录单例模式：就是只有一个实例。单例模式又分为两种基本的情形：饿汉式和懒汉式如下是懒汉式单例类小结：继续看单例模式总结单例模式：就是只有一个实例。 singleton pattern...

99+

2024-04-02
java设计模式之单例模式解析

单例模式是最简单但同时也是很重要的一种设计模式，优点有以下几个方面：当内存占用特别大的类需要频繁地创建销毁时，单例模式可以节省内存和提高性能，例如myBatis里面的sessionFactory当需要对文件做单一读写时，例如同一时间只能同时...

99+

2023-05-31

java 设计模式单例模式
Android设计模式之单例模式解析

在日常开发过程中时常需要用到设计模式，但是设计模式有23种，如何将这些设计模式了然于胸并且能在实际开发过程中应用得得心应手呢？和我一起跟着《Android源码设计模式解析与实战》一书边学边应用吧！今天我们要讲的是单例模式定义确保某一个类只有...

99+

2023-05-30

android 单例模式之单
JAVA设计模式之单例模式详解

目录前言一、单例模式是什么？二、懒汉式单例三、饿汉式单例四、双重校验锁总结前言在之前的文章里已经介绍了设计模式以及设计原则的概念,接下来我们从单例模式入手深入学习几种常用的JAVA...

99+

2024-04-02
24种设计模式之单例模式（饿汉式、懒汉式）

一、单例模式单例模式( Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如,总统，班主任等。J2EE标准中的Servl...

99+

2023-09-23

java Powered by 金山文档
Java设计模式之单例模式

目录什么是设计模式？单例模式是什么？单例模式设计的原则是什么？Java实现单例模式的5种方式？懒汉饿汉静态内部类双重校验锁DCL(Double Check Lock)枚举(num)总...

99+

2024-04-02