JAVA设计模式之单例模式

已于 2022-04-23 18:00:19 修改
阅读量389 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 单例模式
于 2022-03-06 19:41:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apple_53947466/article/details/123315451
版权

单例模式

一、简介

单例模式是指在内存中只会创建且仅创建一次对象的设计模式。
在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升
单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。

二、类型

  • 饿汉式：在类加载时已经创建好对象，等待被程序使用
  • 懒汉式：在需要使用对象时才去创建该单例对象

三、饿汉模式

3.1、正常创建

  • 构造器私有（外部无法直接new对象）
  • 手动创建好一个类对象
  • 提供方法给外部获取该对象
public class Hungry {
    //构造器私有，外部无法直接new对象
    private Hungry() {}
    
    //手动创建静态单实例
    private final static Hungry HUNGRY = new Hungry();

    //给外部提供获取该单实例的方法
    public static Hungry getInstance() {
        return HUNGRY;
    }
}

缺点：可能会浪费内存空间

private byte[] data1 = new byte[1024 * 1024];
private byte[] data2 = new byte[1024 * 1024];
private byte[] data3 = new byte[1024 * 1024];
private byte[] data4 = new byte[1024 * 1024];

3.2、静态内部类

public class Holder {

    private Holder() {
    }

    private static Holder getInstance() {
        return InnerClass.HOLDER;
    }

    public static class InnerClass {
        private static final Holder HOLDER = new Holder();
    }

}

四、懒汉模式

4.1、单线程使用

存在线程不安全的问题

public class Lazy {

    private Lazy() {}

    private static Lazy lazy;

    public static Lazy getInstance() {
        if (lazy == null) {
            lazy = new Lazy();
        }
        return lazy;
    }   
}

如果两个线程同时判断singleton为空，那么它们都会去实例化一个Singleton对象，这就变成双例了。所以，我们要解决的是线程安全问题。
在这里插入图片描述
通过加锁解决
但如果直接在方法或者类上加锁，虽然解决多线程问题，但每次获取对象都要先获取锁，性能比较低

public static synchronized Lazy getInstance() {
    if (lazy == null) {
        lazy = new Lazy();
    }
    return lazy;
}
// 或者
public static Lazy getInstance() {
    synchronized(Lazy.class) {   
        if (lazy == null) {
            lazy = new Lazy();
        }
    }
    return lazy;
}

4.2、双重检测锁(DCL)

如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例

  • 假设AB线程一起执行getInstance()，此时lazy为空，非空判断通过，接着AB争抢锁
  • B抢到了并锁住，再次判断lazy为空(假设别的线程比B先进入，没有这层判断会导致B又创建了对象)，创建对象
  • 轮到A了，判断lazy不为空（没有这层判断会导致A又创建了对象），直接跳出，返回B创建的对象
  • 假设C进来了，非空判断过不去，直接返回B创建的对象
  • 如果没有第一层的判断会导致创建了对象后新线程又获取锁，性能降低
public class Lazy {

    private Lazy() {}
    
    private static Lazy lazy;

    public static Lazy getInstance() {
        if (lazy == null) {		
            synchronized (Lazy.class) {	
                if (lazy == null) {
                    lazy = new Lazy();
                }
            }
        }
        return lazy;
    }

}

解决了性能低效+并发安全的问题，但jvm创建对象的过程存在指令重排的现象

4.3、原子性操作

new对象不是原子性操作，内部执行以下

  1. 分配内存空间
  2. 执行构造方法，初始化对象
  3. 把对象指向内存空间

但jvm有可能出现指令重排（执行132）

  • A线程执行了13，这个时候lazy的内存空间不等于null，但其实对象还未初始化
  • B线程进来了，虽然B进不去同步代码块，但同步代码块前的空判断会判断为非空
  • 此时lazy未完成构造，会直接return空对象

在这里插入图片描述

可以使用volatile关键字防止指令重排的发生

public class Lazy {

    private Lazy() {}

    //防止初始化过程指令重排
    private volatile static Lazy lazy;

    public static Lazy getInstance() {
        if (lazy == null) {
            synchronized (Lazy.class) {
                if (lazy == null) {
                    lazy = new Lazy();
                }
            }
        }
        return lazy;
    }

}

五、反射与单例的斗争

5.1、反射破坏单例

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
    Lazy instance1 = Lazy.getInstance();
    Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);
    //无视私有构造
    declaredConstructor.setAccessible(true);
    Lazy instance2 = declaredConstructor.newInstance();
    System.out.println(instance1);
    System.out.println(instance2);
}

在这里插入图片描述

5.2、私有构造加锁–三重检测锁

但这种只能存在先获取了单例，再通过反射创建对象，如果对象都是反射创建的，这样也无法避免

private Lazy() {
    synchronized (Lazy.class) {
        if (lazy != null) {
            throw new RuntimeException("请勿使用反射破坏单例");
        }
    }
}

在这里插入图片描述

5.3、反射创建对象

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
    //Lazy instance1 = Lazy.getInstance();
    Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);
    //无视私有构造
    declaredConstructor.setAccessible(true);
    Lazy instance2 = declaredConstructor.newInstance();
    Lazy instance3 = declaredConstructor.newInstance();
    System.out.println(instance2);
    System.out.println(instance3);
}

在这里插入图片描述

5.4、私有构造加标记判断

private static boolean laptoy = false;
private Lazy() {
    synchronized (Lazy.class) {
        if (laptoy == false) {
            laptoy = true;
        } else {
            throw new RuntimeException("请勿使用反射破坏单例");
        }
    }
}

在这里插入图片描述

5.5、若标记被找到

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
    //Lazy instance1 = Lazy.getInstance();
    Field laptoy = Lazy.class.getDeclaredField("laptoy");
    laptoy.setAccessible(true);
    Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);
    //无视私有构造
    declaredConstructor.setAccessible(true);
    Lazy instance2 = declaredConstructor.newInstance();
    
	laptoy.set(instance2, false);
	
    Lazy instance3 = declaredConstructor.newInstance();
    System.out.println(instance2);
    System.out.println(instance3);
}

在这里插入图片描述

六、枚举(无法被反射破坏)

6.1、使用

public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance() {
        return INSTANCE;
    }

}

class Test {
    public static void main(String[] args) {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        EnumSingle instance2 = EnumSingle.INSTANCE;  //相同
    }
}

6.2、验证

1、从生成的target目录发现EnumSingle源码类有私有构造
在这里插入图片描述
2、尝试用反射newInstance

class Test {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

3、报错，没有此类型的构造器，也就是没有私有无参构造器
在这里插入图片描述
4、达不到预期，应该是抛出无法反射地创建枚举对象
在这里插入图片描述

5、反编译该类，的确有该构造，但是反射是绝对正确的
在这里插入图片描述
6、使用更专业的反编译工具,发现该类没有无参构造，但有一个有参构造
在这里插入图片描述

class Test {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

达到预期效果，反射无法破坏单例
在这里插入图片描述

Laptoy
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java设计模式之单例模式
Simon学Java
02-09 1036
单例模式是结构最简单的设计模式，在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于被外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。单例模式(Singleton Pattern)定义：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。
java设计模式之单例模式
热门推荐
liu_da_da的博客
06-23 1万+
java设计模式之单例模式
java 设计模式之单例模式
08-31
Java中的单例模式是一种设计模式，它用于控制类的实例化过程，确保在整个应用程序中，一个类只有一个实例存在。这在处理全局资源、缓存、线程池等场景时非常有用，因为它可以避免多个实例之间的数据冲突，节省系统...
全面解析Java设计模式之单例模式
08-28
单例模式是设计模式中的一种基础模式，它确保一个类在任何情况下只有一个实例存在。这种模式的核心在于限制类的实例化，保证全局范围内只有一个对象，同时也提供了一个全局访问点，使得其他部分的代码能够方便地使用...
Java 实现单例模式的几种方法
lt5227的博客
07-18 674
单例模式是一种常用的软件设计模式，其目的是确保一个类在任何情况下只有一个实例，并提供一个全局访问点供外部获取这个唯一的实例。这种模式特别适用于那些具有全局状态的场合，如配置管理器、线程池、缓存、对话管理等。
c++单例模式
m0_55138981的博客
07-15 172
（线程不安全）：在第一次使用时实例化对象。基本的懒汉式实现并不支持多线程环境，因为在多线程环境下可能会创建多个实例。饿汉式单例模式由于其实现简单且线程安全（实例在程序启动时被创建），是实际应用中较为常见的选择。：主要是确保一个类仅有一个实例，并提供一个全局访问点来获取这个实例。常见的有懒汉式和饿汉式。：在程序启动时即创建实例，因此不存在多线程访问时创建多个实例的问题。
设计模式（工厂模式，模板方法模式，单例模式）
m0_73966521的博客
07-16 776
这很容易引发线程不安全问题，我们设想有两个线程，第一个线程需要这个singleton1这个对象，进入了if判断，不过这个时候CPU将线程切换给了第二个线程，那这个时候，第二个线程也进入了if判断，然后CPU再切换会第一个线程，线程一创建了对象，但是我们知道线程二也进入了if判断，它也能创建对象，这就导致了线程不安全问题。所以翻译成Java语言就是，空调是一个抽象类，发动机是一个抽象类，多个抽象类，一个工厂抽象类，不同型号的车是一个类都去继承这个工厂，你需要什么零件就去这个工厂里面配这个零件。
一、单例模式
qq_61350148的博客
07-18 595
讲解了单例模式的 六种实现、一种线程不安全的实现 和 JDK中的单例模式。
单例模式详解
一个喜欢诗和远方的程序媛
07-19 570
单例模式（Singleton Pattern）是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。这种模式在需要一个对象被共享且全局唯一的情况下非常有用，比如配置对象、日志对象、数据库连接对象等。单例模式通过确保一个类只有一个实例，提供了一种全局访问点来访问该实例。根据不同的需求和场景，可以选择不同的实现方式。饿汉式和枚举方式实现简单，但不能延迟加载；懒汉式和双重校验锁方式可以延迟加载，但需要考虑线程安全问题；静态内部类方式兼具延迟加载和线程安全，是一种推荐的实现方式。
LINUX:懒汉单例模式线程池
W2155的博客
07-16 436
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
什么是单例模式，有哪些应用？
最新发布
qq_62571013的博客
07-20 679
本文详细介绍了单例模式，应用场景及6种实现方式。
单例模式~
WYZFJHH的博客
07-18 190
确保一个类只有一个实例，并提供一个全局访问点来访问该实例。
单例模式 饿汉式和懒汉式的区别
weixin_51803498的博客
07-16 455
单例模式（Singleton Pattern）是设计模式中最简单、最常见、最容易实现的一种模式。它确保一个类仅有一个实例，并提供一个全局访问点。单例模式主要有两种实现方式：饿汉式（Eager Initialization）和懒汉式（Lazy Initialization）。
掌握Java常见设计模式：单例实例详解
在本文中，我们将深入探讨其中几种常用的Java设计模式，以单例模式为例进行详细讲解。 1. 单例设计模式 单例模式确保一个类只有一个实例，并提供全局访问点。这种模式常用于创建线程池、数据库连接池等需要控制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Laptoy

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

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

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

打赏作者

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

抵扣说明：

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

余额充值