单例模式-狂神说

已于 2022-12-29 18:35:25 修改
阅读量185 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 单例模式
于 2022-12-28 15:53:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23591001/article/details/128465630
版权

目录

1.什么是单例模式

2. 单例模式的类型

一：饿汉式单例

二：懒汉式

        DCL懒汉式

三：静态内部类

 四：枚举

【狂神说Java】单例模式

1.什么是单例模式

单例模式是指在内存中只会创建且仅创建一次对象的设计模式。

2. 单例模式的类型

一：饿汉式单例

package com.shusl.single;

/*
饿汉式单例
    很饿，一上来就把对象加载了！
    问题：有可能浪费内存
        我想用的时候再去创建这个对象，解决办法：懒汉式单例

单例中最重要的思想：构造器私有
    一旦私有构造器了，别人就无法new这个对象了，保证了内存中只有一个对象
 */
public class Hungry {

    //可能会浪费空间，开辟了空间，却没有使用
    private Hungry(){

    }
    //饿汉式：先 new 对象， 可以保证唯一的
    private final static Hungry HUNGRY = new Hungry();
    //抛出一个对外的方法
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

A类调用：

二：懒汉式

package com.shusl.single;
/*
懒汉式单例
    用的时候再去加载
 */
public class LazyMan01 {
    private  LazyMan01(){
        System.out.println("LazyMan01");
    };
    private  static LazyMan01 lazyMan01;

    public  static LazyMan01 getInstance(){
        if (lazyMan01 == null) {
            lazyMan01 = new LazyMan01();
        }
        return  lazyMan01;
    }

}

多线程并发测试，破坏单例

    //多线程并发
    public static void main(String[] args){
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                LazyMan01.getInstance();
            }).start();
        }
        /*
        *LazyMan01
        LazyMan01
        LazyMan01
         */
    }

多线程并发破坏单例，解决加锁

解决指令重排 ：volatile

DCL懒汉式

package com.shusl.single;

public class LazyMan02 {
    private  LazyMan02(){
       
    };
    private  volatile static LazyMan02 lazyMan02;//volatile 避免指令重排

    //双重检测锁模式的懒汉式单例 DCL
    public  static LazyMan02 getInstance(){
        if(lazyMan02 == null){
            synchronized (LazyMan02.class){//锁class只有一个
                if (lazyMan02 == null) {
                    lazyMan02 = new LazyMan02();//有问题，不是原子性操作
                    /**
                     * 不是原子性操作,会经过三步操作 （底层操作）
                     * 1、分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     * 这样才能保证这个对象 new 完成
                     *
                     * 会发生一个指令重排的情况：
                     * 比如：我们希望它执行123，但是它真实执行了132，这就完了
                     * 比如：第一个线程 A 进来时，执行了132（先把空间占用下来，再把内存对象放进去），
                     * 然后 A 线程没有问题，但是当B线程来的时候就有问题了
                     * 线程 B 由于它已经指向这个内存空间了，它会人为 LazyMan02 ！= null，会return LazyMan02，
                     * 这个时候 这个LazyMan02还没有完成构造，它的空间是虚无的，就会产生一个问题。
                     *
                     * 所有为了安全，一定要在 LazyMan02 中加 volatile，避免指令重排的
                     */
                }
            }
        }

        return  lazyMan02;
    }

}

三：静态内部类

package com.shusl.single;


//静态内部类
public class Holder {

    //构造器私有
    private Holder(){

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

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

    }
}

单例不安全，因为有反射

反射破坏单例测试一：

package com.shusl.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class LazyMan02 {
    private  LazyMan02(){
        System.out.println("LazyMan01");
    };
    private  volatile static LazyMan02 lazyMan02;//volatile 避免指令重排

    //双重检测锁模式的懒汉式单例 DCL
    public  static LazyMan02 getInstance(){
        if(lazyMan02 == null){
            synchronized (LazyMan02.class){//锁class只有一个
                if (lazyMan02 == null) {
                    lazyMan02 = new LazyMan02();
                   
                }
            }
        }

        return  lazyMan02;
    }

    public static void main(String[] args) throws Exception{
        LazyMan02 lazyMan02 =  LazyMan02.getInstance();
        Constructor<LazyMan02> constructor = LazyMan02.class.getDeclaredConstructor(null); //获得构造器
        constructor.setAccessible(true);//无视私有构造器
        LazyMan02 instance = constructor.newInstance();//创建对象
        System.out.println(instance);
        System.out.println(lazyMan02);
/**
 * LazyMan01
 * LazyMan01
 * com.shusl.single.LazyMan02@1b6d3586
 * com.shusl.single.LazyMan02@4554617c
 */
    }



}

解决反射加锁:

package com.shusl.single;

import java.lang.reflect.Constructor;

public class LazyMan03 {
    private LazyMan03() {
        synchronized (LazyMan03.class) {
            if (lazyMan03 != null) {
                throw new RuntimeException("不要试图反射破坏异常");
            }
        }
    }

    private volatile static LazyMan03 lazyMan03;//volatile 避免指令重排

    //双重检测锁模式的懒汉式单例 DCL
    public static LazyMan03 getInstance() {
        if (lazyMan03 == null) {
            synchronized (LazyMan03.class) {//锁class只有一个
                if (lazyMan03 == null) {
                    lazyMan03 = new LazyMan03();

                }
            }
        }

        return lazyMan03;
    }

    public static void main(String[] args) throws Exception {
        LazyMan03 lazyMan03 = LazyMan03.getInstance();
        Constructor<LazyMan03> constructor = LazyMan03.class.getDeclaredConstructor(null); //获得构造器
        constructor.setAccessible(true);//无视私有构造器
        LazyMan03 instance = constructor.newInstance();//创建对象

        System.out.println(instance);
        System.out.println(lazyMan03);
    }
}

问题：两个对象都是反射来定义，破坏单列？

   public static void main(String[] args) throws Exception {
        //LazyMan03 lazyMan03 = LazyMan03.getInstance();
        Constructor<LazyMan03> constructor = LazyMan03.class.getDeclaredConstructor(null); //获得构造器
        constructor.setAccessible(true);//无视私有构造器
        LazyMan03 instance = constructor.newInstance();//创建对象
        LazyMan03 instance2 = constructor.newInstance();//创建对象

        System.out.println(instance);
        System.out.println(instance2);
        /**
         * com.shusl.single.LazyMan03@2a33fae0
         * com.shusl.single.LazyMan03@707f7052
         */
    }

解决：红绿灯：定义标志位

package com.shusl.single;

import java.lang.reflect.Constructor;

public class LazyMan04 {
    //定义标志位
    private static boolean shu = false;
    private LazyMan04() {
        synchronized (LazyMan04.class) {
            if (shu == false){
                shu = true;
            } else {
                throw  new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }

    private volatile static LazyMan04 lazyMan04;//volatile 避免指令重排

    //双重检测锁模式的懒汉式单例 DCL
    public static LazyMan04 getInstance() {
        if (lazyMan04 == null) {
            synchronized (LazyMan03.class) {//锁class只有一个
                if (lazyMan04 == null) {
                    lazyMan04 = new LazyMan04();

                }
            }
        }

        return lazyMan04;
    }

    public static void main(String[] args) throws Exception {
        Constructor<LazyMan04> constructor = LazyMan04.class.getDeclaredConstructor(null); //获得构造器
        constructor.setAccessible(true);//无视私有构造器
        LazyMan04 instance = constructor.newInstance();//创建对象
        LazyMan04 instance2 = constructor.newInstance();//创建对象

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

反射获取字段来破坏单例：



    public static void main(String[] args) throws Exception {
        Field shu = LazyMan04.class.getDeclaredField("shu");
        shu.setAccessible(true);//把这个私有权限也破坏
        Constructor<LazyMan04> constructor = LazyMan04.class.getDeclaredConstructor(null); //获得构造器
        constructor.setAccessible(true);//无视私有构造器
        LazyMan04 instance = constructor.newInstance();//创建对象
        shu.set(instance,false);
        LazyMan04 instance2 = constructor.newInstance();//创建对象

        System.out.println(instance);
        System.out.println(instance2);
        /**
         * com.shusl.single.LazyMan04@4554617c
         * com.shusl.single.LazyMan04@74a14482
         */
    }
}

源码来分析：点入newInstance知道enum反射不能破坏

 四：枚举

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

为什么枚举可以，探寻？？？

打开查看枚举构造方法测试下是不是无参构造：报错没有无参构造

class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        //java.lang.NoSuchMethodException: com.ph.single.EnumSingle.<init>()
        System.out.println(instance);
        System.out.println(instance2);

    }
}

 反编译这个类，

 反编译软件编译之后

知道有参的测试

package com.shusl.single;


import java.lang.reflect.Constructor;

//enmu是什么？本身也是一个class类
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
/*Cannot reflectively create enum objects*/

    }
}

唯快不破VV
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
23中设计模式—–单例模式
01-20
前言 今天听完狂神说java的单例模式，感慨万分。希望通过这篇文章跟大家一起学习。 1. 饿汉式 [1] 一个私有的构造器 [2] 一个静态变量 [3] 一个静态方法返回对象 饿汉式单例是直接使用静态变量的方式生成这个单例对象（不管是否调用) , 所以缺点比较明显就是占用空间。 package com.gs.juc.单例模式; //饿汉式单例 public class Hungry { //可能会造成浪费空间(假设此时有相应的变量生成) //private byte[] data1 = new byte[1024*1024]; // 1. 一个私有的构造器 pri
–设计模式–五种实现单例模式的方式
12-21
单例模式是一种广泛应用的设计模式，它的核心思想是确保一个类只有一个实例，并提供一个全局访问点。这在资源管理、缓存、日志记录等场景下非常有用。在多线程环境下，正确实现单例模式显得尤为重要，因为不恰当的...
设计模式----单例模式
vmfisvi的博客
02-18 148
设计模式----单例模式 什么是单例模式 面试官问什么是单例模式时，千万不要答非所问，给出单例模式有两种类型之类的回答，要围绕单例模式的定义去展开。 单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。 单例模式的类型 单例模式有两种类型： 懒汉式：在真正需要使用对象时才去创建该单例类对象 饿汉式：在类加载时已经创建好该单例对象，等待被程序使用
狂神 - 单例模式
weixin_52093131的博客
12-17 412
文章目录饿汉式单例DCL懒汉式静态内部类总结枚举 单例模式是，每个程序员必须会写的。 枚举 饿汉式单例 package com.y.single; /* 饿汉式单例 很饿，一上来就把对象加载了！ 问题：有可能浪费内存 我想用的时候再去创建这个对象，解决办法：懒汉式单例 单例中最重要的思想：构造器私有 一旦私有构造器了，别人就无法new这个对象了，保证了内存中只有一个对象 */ public class Hungry { //一上来就加载对象了，浪费空间
【狂神说Java】设计模式----单例模式
pan_h1995的博客
06-03 2729
彻底玩转单例模式 恶汉式、DCL懒汉式 恶汉式： package com.ph.single; //恶汉使单利模式 public class Hungry { //可能会浪费空间，开辟了空间，却没有使用 private Hungry(){ } private final static Hungry HUNGRY = new Hungry(); public static Hungry getInstance(){ return HUNG
狂神JUC——单例模式
黄坤的博客
06-02 470
1.饿汉式 package com.company.singleton_pattern; //饿汉式（已经创建好，就等拿了,会浪费空间） public class Hungry { //构造器私有 private Hungry(){ } private static final Hungry hungry = new Hungry(); public static Hungry getInstance(){ return hungry; .
设计模式（第2版）-第9章 单例模式.pptx
03-22
常用设计模式
狂神说JAVA的所有笔记.zip
01-17
在JAVA的进阶部分，笔记可能讲解了设计模式，这是解决常见编程问题的模板，如单例模式、工厂模式、装饰器模式等，能提升代码的复用性和灵活性。同时，可能会涵盖JVM（Java虚拟机）的工作原理，包括内存管理、类加载...
遇见狂神说的全套java视频笔记
05-25
12. **设计模式**：设计模式是解决常见软件设计问题的成熟解决方案，如单例模式、工厂模式、观察者模式等，它们在Java开发中被广泛应用。 “狂神说全部笔记内容”可能详细地解析了以上各个知识点，并通过实例和练习...
单例模式还能这样 ——致敬狂神
qq_38697228的博客
07-08 296
饥汉模式(积极加载) 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面试复习---单例模式（狂神版）
smdbhd的博客
07-15 138
本文是Java面试复习系列中的单例模式，后面会陆续有该系列其他篇章，并且会一直维护。本系列都为网上资源整理而来，如有问题，及时联系。
单例模式
weixin_42903592的博客
12-05 129
单例模式 本文章根据b站狂神说单例模式视频教程整理 b站狂神说单例模式视频链接 饿汉式单例 package com.kuang; /** * @Author: Abe * Date: 2020/12/5 14:24 * 饿汉式单例模式 */ public class Hungry { //造成资源浪费 private byte[] data1 = new byte[1024*1024]; private byte[] data2 = new byte[1024*102
JUC并发编程（狂神说笔记）
qq_39831512的博客
06-02 286
JUC并发编程 什么是JUC java.util.concurrent、java.util.concurrent.atomic、java.util.concurrent.locks这三个包 前期回顾 什么是线程和进程？ 进程：运行中的程序 线程：一个进程包含多个线程，至少包含一个。java默认有两个线程（main线程、GC线程） JAVA并不能真的开启线程（JAVA无法直接操作硬件，是底层C++去做的） public synchronized void start() { /
狂神说Java-Spring笔记
Mr_Lewis的博客
06-02 5217
1.环境搭建 maven搭建一个干净的项目，不使用任何模板 //导入这个包可以同时导入大量其依赖的包，简单 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.0.RELEASE</version> </dependency> 2.
23种设计模式笔记第二篇单例模式
qq_44709970的博客
04-24 366
单例中最重要的就是（一旦构造方法私有，别人就无法new这个对象了）是23种设计模式中最简单的。单例模式是必须学的，不会单例模式的程序员是不合格的，饿汉式、懒汉式、恶汉式，仅此一篇就够了
跟着狂神学设计模式（工厂模式，抽象工厂模式，建造者模式，原型模式，适配器模式，桥接模式，静动态代理模式，单例模式 ）
qq_40649503的博客
12-12 1826
跟着狂神学设计模式（工厂模式，抽象工厂模式，建造者模式，原型模式，适配器模式，桥接模式，静动态代理模式，单例模式 ）
JUC并发编程笔记（狂神说）
THB66666的博客
09-24 452
JUC并发编程 狂神说：https://space.bilibili.com/95256449 1. 什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 源码 + 官方文档 面试高频问！ java.util 工具包 业务：无法通过普通的线程代码 Thread实现。 Runnable 没有返回值、效率相比于Callable相对较低！ 企业开发中Callable 使用较多 Callable ： 锁： 2、线程和进程 进程是操作系统中的应用程序、是资源
设计模式（工厂模式，模板方法模式，单例模式）
最新发布
m0_73966521的博客
07-16 872
这很容易引发线程不安全问题，我们设想有两个线程，第一个线程需要这个singleton1这个对象，进入了if判断，不过这个时候CPU将线程切换给了第二个线程，那这个时候，第二个线程也进入了if判断，然后CPU再切换会第一个线程，线程一创建了对象，但是我们知道线程二也进入了if判断，它也能创建对象，这就导致了线程不安全问题。所以翻译成Java语言就是，空调是一个抽象类，发动机是一个抽象类，多个抽象类，一个工厂抽象类，不同型号的车是一个类都去继承这个工厂，你需要什么零件就去这个工厂里面配这个零件。
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值