[JUC-16] 单例模式

最新推荐文章于 2024-04-27 17:30:34 发布
最新推荐文章于 2024-04-27 17:30:34 发布
阅读量144 收藏
点赞数
分类专栏： 并发编程 文章标签： java 多线程 单例模式 枚举 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29051413/article/details/108007014
版权

文章目录

1、饿汉式

  实现：

public class 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];

    private Hungry() {
    }

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance() {
        return HUNGRY;
    }
}

  存在的问题：如果实例从头到尾就没用过，而这个实例对象又占用了较大内存，容易造成内存泄漏；

  改进：改成需要使用实例对象时再创建。

2、饱汉式（懒加载）

  最简单的实现：

public class LazyMan {

    private LazyMan() {
    }

    private static LazyMan lazyMan;

    public static LazyMan getInstance() {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

  对于单线程，这种实现毫无问题，但是对于多线程来说，如果线程 A 判断完 if 但是还没来得及执行lazyMan = new LazyMan();，此时线程 B 获取 CPU 资源，也来到 if ，也判断为 null，并创建一个实例对象进行返回。接着线程 A 苏醒，又执行了一次创建对象。

  测试代码：

public class Test{
    public static void main(String[] args) throws InterruptedException {
        Thread A = new Thread(()->{
                LazyMan.getInstance();
        });
        Thread B = new Thread(()->{
            LazyMan.getInstance();
        });
        A.start();
        B.start();
    }
}

  运行结果：
在这里插入图片描述
  加个延时：

public class Test{
	public static void main(String[] args) throws InterruptedException {
        Thread A = new Thread(()->{
                LazyMan.getInstance();
        });
        Thread B = new Thread(()->{
            LazyMan.getInstance();
        });
        A.start();
        TimeUnit.SECONDS.sleep(1);
        B.start();
    }
}

  运行结果：
在这里插入图片描述
  可见，多线程下，这种方式的单例模式是有问题的。

  解决方式：使用双重检测锁。

3、DCL懒加载

  DCL：Double Check Lock。

  代码实现：

public class LazyMan {

    private LazyMan() {
        System.out.println("LazyMan 创建了");
    }

    private static LazyMan lazyMan;

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

  无论多少线程，都可以发现只创建了一个实例。

  你可能会问：为什么不干脆在getInstance方法直接加synchronized关键字呢？这是因为，getInstance方法调用是很频繁的，假设已经有了实例，多个线程来获取实例时，总是在判断锁，导致多个线程同时要拿实例时，变得要阻塞了。

  这种 DCL 方式是否一定 OK 呢？答案是 ：No！

  我们学习 volatile 时了解了指令重排的问题。对于语句lazyMan = new LazyMan();我们看起来以为只是一行，其实它底层有三步：
  1、分配内存空间
  2、执行构造方法，初始化对象
  3、把这个对象指向这个空间

  如果是正常的123顺序，那么就没问题。如果来个指令重排，变成了132，就容易出现问题了。

  假设指令重排变成了132。线程 A 进入lazyMan = new LazyMan();语句的3，即对象已经分配了空间，并且引用也指向了这个对象，但是还没有执行构造函数初始化对象。这时，线程 A 暂停，线程 B 进入了获取实例的方法，线程 B 判断出来的是对象不为空，于是线程 B 拿到了一个没有初始化的对象。

  解决方法就是对实例对象加 volatile 关键字。于是，完整的DCL懒加载如下所示：

public class LazyMan {

    private LazyMan() {
        System.out.println("LazyMan 创建了");
    }

    private volatile static LazyMan lazyMan;

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

4、使用枚举实现单例模式

  正所谓道高一尺魔高一丈，我们知道 Java 是有反射机制的，如果有人这样操作：

public class Test{
    public static void main(String[] args) throws Exception {
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan instance1 = constructor.newInstance();
        LazyMan instance2 = constructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

  运行结果：
在这里插入图片描述
  此时发现，DCL的单例模式被反射给破坏了。

  解决方法：在构造器中使用标志变量。

public class LazyMan {

    private static boolean flag = false;

    private LazyMan() {
        synchronized (LazyMan.class) {
            if (flag){
                throw new RuntimeException("我知道已经有了实例你还在创建实例，不要试图使用反射破坏异常");
            }else {
                System.out.println("LazyMan 创建了");
                flag = true;
            }
        }
    }

    private static LazyMan lazyMan;

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

  测试代码：

public class Test{
    public static void main(String[] args) throws Exception {
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan instance1 = constructor.newInstance();
        LazyMan instance2 = constructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

  运行结果：
在这里插入图片描述
  可见，有了实例对象的前提下，如果再调用构造函数，我们就可以知道它是打算破坏单例模式，但是被我们的代码给遏制了。

  但是，这样就完全安全了吗？答案还是：No！

  如果有人这样做：

public class Test{
    public static void main(String[] args) throws Exception {
        Field flag = LazyMan.class.getDeclaredField("flag");
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan instance1 = constructor.newInstance();
        flag.set(instance1,false);
        LazyMan instance2 = constructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

  运行结果：
在这里插入图片描述
  也就是说，创建了一个实例对象后，本来 flag 已经变成 true 了，可是被反射获取后又强行改成了 false，导致还能再成功调用一次构造器。

  我靠，这样搞下去，没法玩了。

  如果不是被人为反射搞破坏，其实DCL懒加载已经够用，既然能被反射搞成这样，那我就从反射本身去想办法。

  查看反射获取的构造器进行创建实例对象的源码：
在这里插入图片描述
  终于找到敌人的弱点了，反射不能搞枚举类型，哈哈哈哈。

  使用枚举实现单例模式：

public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance() {
        return INSTANCE;
    }
}

  使用反射来获取一下：

class Test{
    public static void main(String[] args)throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> constructor = EnumSingle.class.getConstructor();
        constructor.setAccessible(true);
        EnumSingle instance2 = constructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

  运行结果：
在这里插入图片描述
  不对啊，不是应该说枚举不能被反射么，这里的异常显示是找不到构造函数？？

  查看一下这个枚举类型的反编译结果：
在这里插入图片描述
  这不是有空参构造么？

  换一个反编译工具 jad ，对 EnumSingle.class 进行反编译。

jad -sjava EnumSingle.class

  打开反编译的结果：
在这里插入图片描述
  首先可以确定它确实是一个 class，并且继承了 Enum。

  它并没有空参构造，只有一个有参构造private EnumSingle(String s, int i)，那我们就从这里突破：

class Test {
    public static void main(String[] args) throws Exception {
        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);
    }
}

  运行结果：
在这里插入图片描述
  说明枚举类型真的不能被反射进行创建实例。

学哥斌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
23中设计模式—–单例模式
01-20
今天听完狂神说java的单例模式，感慨万分。希望通过这篇文章跟大家一起学习。 1. 饿汉式 [1] 一个私有的构造器 [2] 一个静态变量 [3] 一个静态方法返回对象 饿汉式单例是直接使用静态变量的方式生成这个单例对象...
常见的Java笔试题-JVM-JUC-Core:JUCJVM核心知识点
06-02
单例模式的安全问题 CAS CAS底层原理 CAS缺点 ABA问题 AtomicReference AtomicStampedReference和ABA问题的解决 集合类不安全问题 List CopyOnWriteArrayList Set HashSet和HashMap Map Java锁 公平锁/非公平锁 可重...
JVM的指令重排
人有匪气，代码才能飞起
05-20 620
JVM在执行代码的时候，在不影响最终结果的基础上，可能性的会对指令进行重排 。例如 ： a = 2 ,b = a+3, c=5 . 重排后，可能是 ：a = 2 , c=5,b = a+3。当然上面这个例子看不出什么影响 。再来看看 new Object()的例子 。在JVM中，new Object（）并不属于原子操作，对于 Object a = new Object()，会分为3条指令1、在内存...
Java并发 - JUC 单例模式
DJun的博客
08-22 133
其实在学Spring5源码的时候，就已经罗列了各种单例模式。在此，学习过 java.util.concurrent 包后，站在多线程的角度上分析比较经典的懒汉模式的双重锁校验，又称为DCL懒汉式（Double Check Lock）。 1、逐步进阶，基础版本： private static LazySingleton singleton4; private static LazySingleton lazy() { if (singleton4 == null) { singlet
JUC个人学习笔记16---单例模式
qq_42038061的博客
09-15 97
根据b站UP主狂神说JUC课程所写的个人学习笔记 视频地址：https://www.bilibili.com/video/BV1B7411L7tE?from=search&seid=14761503393031794075 饿汉式，懒汉式 饿汉式 public class Hungry { //可能会浪费空间 private byte[] data1 = new byte[1024*1024]; private Hungry(){ } privat
Java设计模式------单例模式
萌新Java工程师
12-20 247
单例模式 简单介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。 比如Hibernate的SessionFactory,它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，-般情况下，一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式。 单例模式有八种方式: 1)饿汉式(静态常量) 2)饿汉式(静态代码块) 3) 懒汉式(线程
leetcode下载-JavaLearn:算法、JVM、JUC、设计模式学习记录（Java语言实现）
06-29
leetcode下载 JavaPractise 这个repo是个人学习算法、JVM、JUC、设计...单例模式的6种写法 3.jvm包 子类父类的加载顺序 4.juc包 创建线程的4种方式 lock接口的学习 5.JavaABC包下是一些Java基础知识的代码练习 nio 反射
Java-Programmer-Practice:Java工程师成长之路，包含JDK源码解析、Java并发编程、JVM实例解析、Spring全家桶、Spring Cloud以及各类中间件代码实例与教程。欢迎fork、star
04-19
单例模式（饿汉式、懒汉式） 4. Linux的基础知识 Linux下的进程 Linux定时任务调度 Linux的七个运行级别 Linux进程启动顺序 深入理解Linux下的守护进程 理解Linux配置文件 下一阶段更新计划 增加JDK源码的注释 + ...
Java面试：Java面试，Java基础，JVM，JUC（高并发），Java8新特性，集合，NIO，计算机基础，计算机网络，操作系统，数据结构，计算机组成原理，数据库，MySql，Oracle，Redis，设计模式，Python，工作流（Activiti），规则引擎（Drools），Spring，SpringCloud，Dubbo，Maven，Mybatis，JWT，Netty，Nginx，Shiro，Zookeeper，消息位置（MQ），微服务，Git，Docker，Utils， Linux，Shell
02-05
Java面试 （速度加快） GitHub： : 编码云： : 作者介绍 作者介绍：笔者是19年本科毕业，现在在成都这边工作，是一名对技术有追求的开发者。希望记录下自己学习和成长的...现在只有单例，工厂，建造者，代理 Python
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 796
都是符合我们的预期的。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 868
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1806
c++中string的模拟实现，面试必会知识点
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 856
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1063
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
C语言案例——输出 Fibonacci 数列（斐波那契数列）的前 40 项
悟道子HD
04-25 484
输出 Fibonacci 数列（斐波那契数列）的前 40 项 #include void main() { int a[40]= {1,1}; int i; printf( "%12d%12d",a[0],a[1]); for(i=2; i
PageHelper实现分页查询
m0_63849044的博客
04-24 1111
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 351
待更新。
迭代器模式
LuckFairyLuckBaby的博客
04-23 729
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
使用JUC-3模型机汇编语言编写程序，在主存中有10个数，统计奇数的个数
06-12
好的，根据您的要求，我会使用 JUC-3 模型机汇编语言编写程序，统计主存中的奇数个数。以下是程序代码： ``` ORG 0 START: LDA COUNT ; 将计数器的值置为0 STA COUNTER LDA #10 ; 设置循环次数为10 STA LOOP ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值