单例模式 - 狂神 - 雁迟

于 2021-07-12 22:53:42 发布
阅读量166 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51311218/article/details/118685869
版权

彻底玩转单例模式

资源来源：哔哩哔哩 - 狂神说

懒汉式、DCL饿汉式，深究！

饿汉式单例：

// 饿汉式单例
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;
    }
    

}

缺点： 可能会浪费空间

懒汉式单例：

public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private static LazyMan lazyMan;

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

    // 单线程下没问题。多线程并发测试
    public static void main(String[] args){
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }

}

测试结果：

image-20210519231113414

修改：添加双重检测锁模式（DCL懒汉式）

public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    // volatile 避免指令重排
    private volatile static LazyMan lazyMan;

    // 双重检测锁模式的 懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan == null){
            synchronized(LazyMan.class){
                if(lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    // 单线程下没问题。多线程并发测试
    public static void main(String[] args){
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }

}

测试结果：

image-20210519231820908

静态内部类方式

// 静态内部类
public class Holder {
    private Holder(){

    }

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

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

}

反射与懒汉单例

破坏：通过 反射 破坏双重检测锁模式

// 反射！
public static void main(String[] args) throws Exception{
    LazyMan instance1 = LazyMan.getInstance();

    // 获取构造器
    Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
    // 开启赋权（暴力反射）
    declaredConstructor.setAccessible(true);
    // 获取实例对象
    LazyMan instance2 = declaredConstructor.newInstance();

    System.out.println(instance1);
    System.out.println(instance2);


}

测试结果：破坏了单例

image-20210712163614819

防止：在无参构造里面加锁判断

public class LazyMan {

    private LazyMan(){
        synchronized (LazyMan.class){
            if (lazyMan != null){
                throw new RuntimeException("不要试图使用反射破坏单例！！！");
            }
        }
    }

    // volatile 避免指令重排
    private volatile static LazyMan lazyMan;

    // 双重检测锁模式的 懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan == null){
            synchronized(LazyMan.class){
                if(lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

测试结果：

image-20210712165958514

破坏：第一次不new对象，使用反射获取两次实例对象。

    public static void main(String[] args) throws Exception{
//        LazyMan instance1 = LazyMan.getInstance();

        // 获取构造器
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        // 开启赋权（暴力反射）
        declaredConstructor.setAccessible(true);
        // 同一个构造器
        // 获取实例对象
        LazyMan instance1 = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
    }

image-20210712200020054

防止：设置红绿灯标志位来防止

不通过反编译的技术，没法获取标志位！

public class LazyMan {

    private static boolean flag = false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if(!flag){
                flag = true;
            }else {
                throw new RuntimeException("不要试图使用反射破坏单例！！！");
            }
        }
    }
}

image-20210712195142283

破坏：通过反编译获取标志位，开启暴力反射进行赋值操作

    // 反射！
    public static void main(String[] args) throws Exception{
//        LazyMan instance1 = LazyMan.getInstance();

        // 获取属性字段
        Field flag = LazyMan.class.getDeclaredField("flag");
        // 暴力反射，获取私有属性
        flag.setAccessible(true);

        // 获取构造器
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        // 开启赋权（暴力反射）
        declaredConstructor.setAccessible(true);
        // 获取实例对象
        LazyMan instance1 = declaredConstructor.newInstance();
        // 修改标志位为false
        flag.set(instance1,false);

        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);


    }

image-20210712200020054

防止：反射不能破坏枚举，写枚举类进行测试

package com.yanchi;

import java.lang.reflect.Constructor;

public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class MyTest{
    public static void main(String[] args) throws Exception{
        EnumSingle instance1 = EnumSingle.INSTANCE;

        // java.lang.NoSuchMethodException: com.yanchi.EnumSingle.<init>()
        // 这个报错信息和预期不符合，通过反编译查看真实源代码
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);

        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);

    }
}

image-20210712201904075

报错信息和预期不符合，通过反编译查看真实源代码

使用专业工具进行反编译：JAD

命令：jad -sjava 类文件

反编译得到的java文件：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   EnumSingle.java

package com.yanchi;


public final class EnumSingle extends Enum
{

    public static EnumSingle[] values()
    {
        return (EnumSingle[])$VALUES.clone();
    }

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(com/yanchi/EnumSingle, name);
    }

    private EnumSingle(String s, int i)
    {
        super(s, i);
    }

    public EnumSingle getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingle INSTANCE;
    private static final EnumSingle $VALUES[];

    static 
    {
        INSTANCE = new EnumSingle("INSTANCE", 0);
        $VALUES = (new EnumSingle[] {
            INSTANCE
        });
    }
}

由此可知：枚举类中没有无参构造。

修改测试类继续测试：

package com.yanchi;

import java.lang.reflect.Constructor;

public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class MyTest{
    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);
        // 报错信息：Cannot reflectively create enum objects
        EnumSingle instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);

    }
}

得到想要的结果：

image-20210712224915344

测试结束！！！

Main12138
关注
专栏目录
狂神说JAVA的所有笔记.zip
01-17
内附网盘下载链接
狂神JUC——单例模式
黄坤的博客
06-02 482
1.饿汉式 package com.company.singleton_pattern; //饿汉式（已经创建好，就等拿了,会浪费空间） public class Hungry { //构造器私有 private Hungry(){ } private static final Hungry hungry = new Hungry(); public static Hungry getInstance(){ return hungry; .
设计模式----单例模式
vmfisvi的博客
02-18 161
设计模式----单例模式 什么是单例模式 面试官问什么是单例模式时，千万不要答非所问，给出单例模式有两种类型之类的回答，要围绕单例模式的定义去展开。 单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。 单例模式的类型 单例模式有两种类型： 懒汉式：在真正需要使用对象时才去创建该单例类对象 饿汉式：在类加载时已经创建好该单例对象，等待被程序使用
单例模式还能这样 ——致敬狂神
qq_38697228的博客
07-08 337
饥汉模式(积极加载) public class Hungry { byte[] byts1 = new byte[1024*1024]; byte[] byts2 = new byte[1024*1024]; byte[] byts3 = new byte[1024*1024]; byte[] byts4 = new byte[1024*1024]; private Hungry(){}//构造器私有化 private static Hungry instance = new Hungry()
【狂神说Java】设计模式----单例模式
pan_h1995的博客
06-03 2793
彻底玩转单例模式 恶汉式、DCL懒汉式 恶汉式： package com.ph.single; //恶汉使单利模式 public class Hungry { //可能会浪费空间，开辟了空间，却没有使用 private Hungry(){ } private final static Hungry HUNGRY = new Hungry(); public static Hungry getInstance(){ return HUNG
smbms---狂神说
07-14
【smbms——狂神说】是一个基于JavaWeb技术开发的管理系统，主要涵盖了企业级应用中的常见功能模块，是学习和实践JavaWeb开发的良好案例。在这个项目中，开发者可以深入理解到如何运用Java、Servlet、JSP、MVC设计...
SpringBoot之员工系统静态资料---狂神.zip
12-28
《SpringBoot之员工系统静态资料---狂神》 在IT领域，SpringBoot是一个备受瞩目的框架，它极大地简化了基于Spring的应用开发。本资料包“SpringBoot之员工系统静态资料---狂神.zip”聚焦于使用SpringBoot构建员工...
Javaweb--狂神版
12-26
"狂神版"很可能指的是由某位知名讲师或专家整理的一套JavaWeb学习资源，这个压缩包可能包含了一个完整的JavaWeb项目实例——SMBMS。 SMBMS（Small and Medium Business Management System）可能是小型和中型企业...
–设计模式–五种实现单例模式的方式
12-21
单例模式是一种广泛应用的设计模式，它的核心思想是确保一个类只有一个实例，并提供一个全局访问点。这在资源管理、缓存、日志记录等场景下非常有用。在多线程环境下，正确实现单例模式显得尤为重要，因为不恰当的...
thread.zip--狂神多线程+juc
03-18
《狂神多线程+juc》是一份针对Java并发编程深度学习的资源包，主要涵盖了Java多线程基础以及Java并发工具集（JUC）的高级应用。在Java编程中，多线程是提高程序效率、实现并发执行的重要手段，而JUC（Java ...
DCL（双锁检测）单例模式
春卷同学的博客
05-12 1354
我们第一次写的单例模式是下面这样的： public class Singleton { private static Singleton instance = null; public static Singleton getInstance() { if(null == instance) { // line A ...
DCL之单例模式
silencefly的博客
06-02 202
最近看到一篇写的DCL之单例模式的文章写的非常好，忍不住想转发，先贴原文链接，顺便自己记一边 https://blog.csdn.net/hongyinanhai00/article/details/113971787 所谓的DCL 就是 Double Check Lock,即双重锁定检查，在了解DCL在单例模式中如何应用之前，我们先了解一下单例模式。单例模式通常分为“饿汉”和“懒汉”，先从简单入手 饿汉 所谓的“饿汉”是因为程序刚启动时就创建了实例，通俗点说就是刚上菜，大家还没有开始吃的时候就先自己吃
dcl单例模式
weixin_43698400的博客
08-02 232
有时候我们需要对外呈现只有一个对象，简单来说就是讲对象私有化，像数据那样，只能通过get方法得到。这里使用doublechecking来进行该操作，即在get方法里面加入两个判断该对象是否为空，同时为了避免指令重排导致线程获得空对象，加入volatile，而且私有化构造器。 public class DoubleChecking { private volatile static D...
DCL单例模式
Ingsuifon的博客
02-10 269
单例模式：对外只能有一个对象（如任务管理器） /** * 单例模式：懒汉式套路基础上加入并发控制，保证在多线程环境下，对外存在一个对象 * 1、构造器私有化-->避免外部new对象 * 2、提供私有的静态属性-->存储对象的地址 * 3、提供公共的静态方法-->获取属性 */ public class DoubleCheckedLocking { //1、构造器...
单例模式-DCL
qq_30231473的博客
06-10 167
铁子们有段时间没有更新了，最近忙着准备面试，准备过程中发现自己还需要积累的实在是太多太多，每每学到新东西的感觉真是美妙而又动力十足啊，继续伸直腰杆、努力前进 单例模式-DCL 双重检查判断，使用volatile关键字禁止指令重排，在多线程情况下创建安全的单例对象，直接上代码 public class Instance { /** * volatile 禁止指令重排，按照代码执行顺序先赋值后创建对象 */ private volatile static Instance
狂神说java-juc并发编程
最新发布
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Main12138

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

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

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

打赏作者

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

抵扣说明：

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

余额充值