设计模式之单例模式

最新推荐文章于 2024-08-15 20:08:51 发布
最新推荐文章于 2024-08-15 20:08:51 发布
阅读量544 收藏
点赞数 1
分类专栏： 设计模式 并发编程 文章标签： 单例模式 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangshuai66/article/details/127354105
版权
本文详细介绍了设计模式中的单例模式，包括其应用场景、优缺点、特点以及7种实现方式，如懒加载、饿汉式、静态内部类实现等。同时，讨论了如何通过反射和序列化破解单例，并提供了防止破解的建议。
摘要由CSDN通过智能技术生成

单例模式

什么是单例模式：JVM中对象只有一个实例的存在

单例的应用场景：

  1. 项目中定义的配置文件
  2. Servlet对象默认为单例
  3. 线程池、数据库连接池（这里体现了复用机制）
  4. Spring中的Bean对象
  5. 一个网站的计数器
  6. JVM内置缓存框架（定义一个单例的HashMap）
  7. 枚举（最安全的单例）

单例模式的优缺点：

  • 优点：能够节约当前堆内存空间，不需要频繁new对象，能够快速访问；
  • 确定：当多个线程访问同一个单例对象的时候可能存在线程安全问题（懒加载的时候）

单例模式特点

  1. 构造方法私有化
  2. 实例化的变量引用私有化
  3. 获取实例的方法共有

单例的写法（7种）：

绝非像鲁迅笔下“茴的4种写法”那样毫无意义

  1. 懒加载（线程不安全版）
  2. 懒加载（线程安全版）
  3. 懒加载（双重检验锁）
  4. 饿汉式
  5. 静态代码块（饿汉式）
  6. 静态内部类（懒汉式）
  7. 枚举实现

懒加载（线程不安全版）

懒汉式基本概念：当真正获取到该对象时，才会创建该对象

public class Singleton01 {
    //实例化的变量引用私有化
    private static Singleton01 singleton = null;

    /**
     * 私有化构造函数
     */
    private Singleton01() {

    }

    public static Singleton01 getSingleton() {
        if (singleton == null) {
            singleton = new Singleton01();
        }
        return singleton;
    }

    public static void main(String[] args) {
        Singleton01 singleton1 = Singleton01.getSingleton();
        Singleton01 singleton2 = Singleton01.getSingleton();
        System.out.println(singleton1 == singleton2);
    }
}

懒加载（线程安全版）

问题：什么时候会出现线程安全问题？

当第一次new出该对象 并赋值到私有引用变量singleton 后面的所以线程直接获取该singleton对象，不需要重复new

public class Singleton02 {
    //实例化的变量引用私有化
    private static Singleton02 singleton = null;

    /**
     * 私有化构造函数
     */
    private Singleton02() {

    }

    //  创建和读取对象都需要获取Singleton01 锁
    public static synchronized Singleton02 getSingleton() {
        if (singleton == null) {
            singleton = new Singleton02();
        }
        return singleton;
    }

    public static void main(String[] args) {
        Singleton02 singleton1 = Singleton02.getSingleton();
        Singleton02 singleton2 = Singleton02.getSingleton();
        System.out.println(singleton1 == singleton2);
    }
}

懒加载（双重检验锁）

双重校验锁（DCL）能够保证线程安全，只会在创建单例兑现时候上锁，获取该单例对象不会上锁，效率比较高。

volatile（避免了重排序，new操作非原子性操作，防止多个线程进行重排序）

public class Singleton03 {
    //实例化的变量引用私有化
    private static volatile Singleton03 singleton = null;

    /**
     * 私有化构造函数
     */
    private Singleton03() {

    }

    //  创建和读取对象都需要获取Singleton01 锁
    public static Singleton03 getSingleton() {
        if (singleton == null) {
            synchronized (Singleton03.class) {
                if (singleton == null) {
                    singleton = new Singleton03();
                }
            }
        }
        return singleton;
    }

    public static void main(String[] args) {
        Singleton03 singleton1 = Singleton03.getSingleton();
        Singleton03 singleton2 = Singleton03.getSingleton();
        System.out.println(singleton1 == singleton2);
    }
}

饿汉式

提前创建单例对象，优点：先天性线程安全 缺点：占内存

public class Singleton04 {
    // 当我们class被加载时，就会提前创建singleton对象
    private static Singleton04 singleton = new Singleton04();

    /**
     * 私有化构造函数
     */
    private Singleton04() {

    }

    public static Singleton04 getSingleton() {
        return singleton;
    }

    public static void main(String[] args) {
        Singleton04 singleton1 = Singleton04.getSingleton();
        Singleton04 singleton2 = Singleton04.getSingleton();
        System.out.println(singleton1 == singleton2);
    }
}

静态代码块（本质就是饿汉式）

public class Singleton05 {
    // 当我们class被加载时，就会提前创建singleton对象
    private static Singleton05 singleton = null;

    static {
        singleton = new Singleton05();
        System.out.println("static执行");
    }

    /**
     * 私有化构造函数
     */
    private Singleton05() {

    }

    public static Singleton05 getSingleton() {
        return singleton;
    }

    public static void main(String[] args) {
        Singleton05 singleton1 = Singleton05.getSingleton();
        Singleton05 singleton2 = Singleton05.getSingleton();
        System.out.println(singleton1 == singleton2);
    }
}

静态内部类（懒汉式）

静态内部类，在Spring框架源码中，经常发现使用静态内部类

其虽然是懒汉式，但具有先天性线程安全

public class Singleton06 {

    /**
     * 私有化构造函数
     */
    private Singleton06() {

    }

    private static class SingletonHolder {
        private static Singleton06 singleton = new Singleton06();
    }

    public static Singleton06 getSingleton() {
        return SingletonHolder.singleton;
    }

    public static void main(String[] args) {
        Singleton06 singleton1 = Singleton06.getSingleton();
        Singleton06 singleton2 = Singleton06.getSingleton();
        System.out.println(singleton1 == singleton2);  //true
    }
}

枚举实现

枚举属于目前最安全的单例，不能够被反射(这里指反射创建，可以参考Constructor的newInstance源码，如果类型是Enum会抛出一个异常) 不能序列化和反序列化保证单例

public enum Singleton03 {
    INSTANCE;

    public void getInstance() {
        System.out.println("<<<getInstance>>>");
    }
}

创建对象的几种方式

1.直接new对象

2.采用克隆对象

3.使用反射创建对象

4.序列化与反序列化

如何破解单例

  1. 反射破解单例(懒加载的情况下)
public class Singleton01 {
    //实例化的变量引用私有化
    private static volatile Singleton03 singleton = null;

    /**
     * 私有化构造函数
     */
    private Singleton03() {

    }

    //  创建和读取对象都需要获取Singleton01 锁
    public static Singleton03 getSingleton() {
        if (singleton == null) {
            synchronized (Singleton03.class) {
                if (singleton == null) {
                    singleton = new Singleton03();
                }
            }
        }
        return singleton;
    }

    public static void main(String[] args) {
		 Class<?> aClass = Class.forName("top.beau.Singleton01");
		 Singleton01 singleton03 = (Singleton01) aClass.newInstance();
      	   // 使用反射破解单例
//        Singleton01 singleton01 = Singleton01.getSingleton01();
//        Singleton01 singleton02 = Singleton01.getSingleton01();
//        // 使用反射破解单例

//        System.out.println(singleton02 == singleton03);  false
    }
    }
}

如何防止反射单例被破解

  1. 不使用懒汉式（静态内部类除外）
  2. 反射创建单例置于 new获取单例对象之后
2、序列化破解单例

序列化：将对象转换成二进制的形式

反序列化：从硬盘/网络读取二进制变为对象

public class Singleton02 implements Serializable {
    private static Singleton02 singleton = new Singleton02();


    public static Singleton02 getSingleton() {
        return singleton;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1.将对象序列化存入到本地文件中
        FileOutputStream fos = new FileOutputStream("d:/code/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        Singleton02 singleton1 = Singleton02.getSingleton();
        oos.writeObject(singleton1);
        oos.close();
        fos.close();
        System.out.println("----------从硬盘中反序列化对象到内存中------------");
        //2.从硬盘中反序列化对象到内存中
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/code/a.txt"));
        // 从新获取一个新的对象
        Singleton02 singleton2 = (Singleton02) ois.readObject();
        System.out.println(singleton1 == singleton2);
    }
//如何防御反序列化创建新的对象
    //java层面 封装好了
	//    readObject 通过反射技术 序列化类中存在readResolve方法 保证单例
  private Object readResolve() throws ObjectStreamException {
     return singleton;
  }
}


  
 序列化类中存在readResolve方法 保证单例
原理：

1. 调用readObject() 

2. 执行readObject0();

3. Switch 判断 
![请添加图片描述](https://img-blog.csdnimg.cn/73177be3dcfa405fa919828f7991bfa0.png)

判断反序列化类中如果存在readResolve方法 则通过反射机制调用readResolve方法返回相同的对象
欢迎大哥光临小弟博客
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式之单例模式
Simon学Java
02-09 1079
单例模式是结构最简单的设计模式，在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于被外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。单例模式(Singleton Pattern)定义：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。
JAVA设计模式之单例模式
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
PHP语言设计模式之单例模式
低头赶路，敬事如仪
12-03 774
第1关：饿汉式
设计模式之单例模式(C++)
翟天保的博客
02-09 2万+
介绍设计模式之单例模式
java设计模式之单例模式
liu_da_da的博客
06-23 1万+
java设计模式之单例模式
一文带你彻底搞懂设计模式之单例模式！！由浅入深，图文并茂，超超超详细的单例模式讲解！！
祝你身体健康，美满幸福
06-28 2604
本篇文章通过图文形式，由浅入深，详细讲解了设计模式中的单例模式的应用
C# 设计模式之单例模式
鲤籽鲲的博客
07-31 969
C# 设计模式之单例模式
设计模式之单例模式（七种方法超详细）
weixin_63834061的博客
04-22 1万+
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，也就是说不能使用new关键字来创建对象。
PHP设计模式之单例模式定义与用法分析
01-03
单例模式（Singleton Pattern 单件模式或单元素模式），是常见的一种设计模式，它有三个特点 1．只能有一个实例 2．必须自行创建这个实例 3．必须给其他对象提供这一实例 下面用PHP代码实现一下 <?PHP /** *...
玩转单例模式
m0_73381672的博客
08-15 1055
所谓单例模式，就是是某个类的实例对象只能被创建一次，单例模式两种实现：饿汉式和懒汉式。
C#单例模式
qq_25194681的博客
08-14 507
当 s_instance 为 null时，它会创建一个新的 Singleton实例，并将42作为状态传递给构造函数。由于构造函数是私有的，因此外部代码无法直接创建 Singleton 类的实例。单例模式是一种常用的设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。- 公共静态属性：public static Singleton Instance 提供全局访问点，确保全局只有一个实例。- 私有静态实例：private static Singleton s_instance用于存储类的唯一实例。
设计模式--单例模式
最新发布
qq_29751083的博客
08-15 461
每种实现方式都有其优缺点，在选择时可以根据实际需求进行考虑。例如，如果你的应用程序是多线程环境并且希望实例在第一次使用时创建，那么可以采用双重检查锁定的方式；如果你的应用程序是单线程环境，那么简单的懒汉式实现就足够了。单例模式是一种常用的软件设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式经常用于系统中只需要一个实例的对象，例如日志管理器、数据库连接池、线程池等。
单例模式的几种写法及破坏
m0_63530048的博客
08-15 544
在这三步中，第2、3步有可能会发生指令重排现象，创建对象的顺序变为1-3-2，会导致多个线程获取对象时，有可能线程A创建对象的过程中，执行了1、3步骤，线程B判断singleton已经不为空，获取到未初始化的singleton对象，就会报NPE异常。为了防止这种行为破坏单例模式，你需要重写 `readResolve()` 方法，在 `readResolve()` 方法中返回单例实例的引用，这样即使经过序列化和反序列化，你仍然只会有一个单例实例。输出到文件中，在读入文件反序列化成对象时，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值