java彻底搞懂单例模式

最新推荐文章于 2024-05-14 06:46:22 发布
最新推荐文章于 2024-05-14 06:46:22 发布
阅读量225 收藏
点赞数
分类专栏： 设计模式 文章标签： java 单例模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smy_0114/article/details/126152205
版权

彻底搞懂单例模式

前情提要：

  • 饿汉式、懒汉式、静态内部类？蜻蜓点水
  • volatitle关键字禁止指令重排之JMM内存模型？重在理解看不见
  • 反射破坏单例？
  • 枚举实现单例，反射无法破坏？
什么是单例模式：

百度百科：是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例。

应用场景：
  1. 操作系统的任务管理器，因为同一台电脑无法同时打开两个任务管理器界面。
  2. 程序的日志系统，因为如果同时有两个程序维护日志文件，日志内容无法追加。
  3. web应用中配置文件的读取，因为配置文件是共享资源，非单例会创建多个相同的资源对象浪费系统内存、CPU等的性能。
  4. 垃圾回收机制。
  5. 线程池和连接池的实现。
以上可以看出，单例模式的应用场景：
共享资源的访问使用单例，如配置信息、日志信息等，避免建立多个相同的对象浪费系统资源
控制资源的访问使用单例，如线程池、连接池等，方便对于访问的资源进行控制。
实现套路：
  1. 构造方法私有化
  2. 提供一个静态方法获取对象实例
饿汉式-可用
  1. 优点：简单方便，避免多线程问题
  2. 缺点：类加载的时候完成初始化，如果未使用会在成内存浪费
//饿汉式，容易造成内存浪费
class HungrySingle{
    //模拟内存浪费
    private static Byte[] a = new Byte[1024*1000];
    private HungrySingle(){
        System.out.println(Thread.currentThread().getName());
    }
    //默认直接初始化对象实例
    private static final HungrySingle instance = new HungrySingle();
    public static HungrySingle getInstance(){
        return instance;
    }
}

测试：启动30个线程，构造方法只会执行一次。为避免内存浪费可以再实际调用的时候再初始化实例对象，因此下面的懒汉式应运而生。

静态内部类
//静态内部类
class StaticInnerClassSingle{
    private StaticInnerClassSingle(){}

    private static class StaticInnerClassSingleInstance {
        private static StaticInnerClassSingle singleton = new StaticInnerClassSingle();
    }

    public static StaticInnerClassSingle getInstance(){
        return StaticInnerClassSingleInstance.singleton;
    }
}
懒汉式-不可用
  1. 优点：无
  2. 缺点：只能在单线程下使用
//懒汉式，线程不安全
class LazySingle{
    private LazySingle(){
        System.out.println(Thread.currentThread().getName());
    }
    //默认不初始化，调用的时候再初始化
    private static LazySingle instance;
    public static LazySingle getInstance(){
        if(instance== null){
            instance = new LazySingle();
        }
        return instance;
    }
}

测试：多线程调用出现多次调用构造器，因此改进为加synchronized关键字。

懒汉式-同步代码块-不可用

忽略同步方法模式，直接使用同步代码块，粒度更小

//懒汉式，同步代码块
class LazySyncSingle{
    private LazySyncSingle(){
        System.out.println(Thread.currentThread().getName());
    }
    private volatile static LazySyncSingle instance;
    public static LazySyncSingle getInstance(){
        if(instance== null){
            synchronized (LazySyncSingle.class){
                instance = new LazySyncSingle();
            }
        }
        return instance;
    }
}

测试：多线程下调用创建实例不能保证安全，假如一个线程进入了if 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

懒汉式-DCL-可用
//懒汉式，加锁双重校验
class LazySyncDoubleCheckSingle{
    private LazySyncDoubleCheckSingle(){
        System.out.println(Thread.currentThread().getName());
    }
    private static LazySyncDoubleCheckSingle instance;
    public static LazySyncDoubleCheckSingle getInstance(){
        //第一次校验
        if(instance== null){
            //class模板全局唯一
            synchronized (LazySyncDoubleCheckSingle.class){
                //第二次校验
                if(instance== null){
                    //不是原子操作指令重排会导致对象虚化
                    instance = new LazySyncDoubleCheckSingle();
                }
            }
        }
        return instance;
    }
}

测试：多线程下结果和预期一致，只会调用一次构造器。

但是instance = new LazySyncDoubleCheckSingle()并不是一个原子操作，先研究下创建一个字符串执行了什么。

/**
 * @author my
 */
public class MySingle {
    public static void main(String[] args) {
    	String str = new String("a");
	}
}

找到class文件直接javap -c MySingle.class

一个对象的创建需要经历0 6 9 三个步骤，在一些极端情况下当线程1执行到0发生指令重排，指令9和6位置互换，即对象已经建立了关联关系但是并未执行6的init，此时线程2进来第一个if判断是否为null，此时已经不为null了，直接把创建了一半的对象返回了，这就是安全所在，要验证这个抱歉电脑太差模拟不出来，因此为了避免这种不安全的情况引入volatile关键字保证jvm在执行时不会发生指令重排。

JMM内存模型：

volatile:在编译期间，会在生成指令序列的时候，会在一些禁止重排序的地方，插入内存屏障从而禁止操作系统对指令进行重排序。

懒汉式-DCL+volatile-推荐
//懒汉式，加锁双重校验,禁止指令重排
class LazySyncDoubleCheckVolatitleSingle{
    private LazySyncDoubleCheckVolatitleSingle(){
        System.out.println(Thread.currentThread().getName());
    }
    //禁止指令重排
    private static volatile LazySyncDoubleCheckVolatitleSingle instance;
    public static LazySyncDoubleCheckVolatitleSingle getInstance(){
        if(instance== null){
            synchronized (LazySyncDoubleCheckVolatitleSingle.class){
                if(instance== null){
                    instance = new LazySyncDoubleCheckVolatitleSingle();
                }
            }
        }
        return instance;
    }
}
反射破坏单例
/**
 * @author my
 */
public class MySingle {
    public static void main(String[] args) throws Exception {
        Constructor<LazySyncDoubleCheckVolatitleSingle> declaredConstructor =
            LazySyncDoubleCheckVolatitleSingle.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        LazySyncDoubleCheckVolatitleSingle instance1 = declaredConstructor.newInstance();
        LazySyncDoubleCheckVolatitleSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

测试：因此上面所讲的单例在一定程度上都是不可用的。

那么我们要如何去避免这种情况呢？

枚举
/**
 * @author my
 */
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        System.out.println(EnumSingle.INSTANCE);
        System.out.println(EnumSingle.INSTANCE);
    }
}

测试：两次生成的对象一样单例ok

反射破坏枚举单例
/**
 * @author my
 */
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        Constructor<EnumSingle> declaredConstructor = 
            EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        //NoSuchMethodException: com.example.studyjuc.EnumSingle.<init>()
        System.out.println(declaredConstructor.newInstance());
    }
}

查看源码：应该报错是Cannot reflectively create enum objects才对呀

    @CallerSensitive
    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

反编译刚才那个类

javap -p EnumSingle.class

这里看到是有这个无参构造器但是为什么报错说没有呢？

说明这个反编译还是不是很理想，用jad反编译，发现有一个有参的构造器

jad -sjava EnumSingle.class

// 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.example.studyjuc;


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/example/studyjuc/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
        });
    }
}

修改反射

class Test{
    public static void main(String[] args) throws Exception {
        Constructor<EnumSingle> declaredConstructor = 
            EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        //NoSuchMethodException: com.example.studyjuc.EnumSingle.<init>()
        System.out.println(declaredConstructor.newInstance());
    }
}

测试：因此发现枚举的单例是无法被破坏

RT_0114
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 单例模式的写法及优缺点getInstance
码点
09-28 798
总结下Java单例模式的几种写法： 1.饿汉式 public class Singleton { private static Singleton instance = new Singleton(); private Singleton() {} public static Singleton getInstance() { return instance; } } 优点：实现简单，不存在多线程问题，直接声明一个私有对象，然后对外提供一个获取对象
细读Java单例模式
mxy2404830的博客
12-21 510
Java中的单例模式看似是一个很简单的设计模式，但事实上，我们可以整出各种各样的“幺蛾子”。单例模式有着不同的实现方式，也很难找到完美的方式。今天我就来分享一下，单例模式的几种常用实现模式以及存在的问题。 之前我写过文章讲解单例模式，不过那个是最简单的方式，还漏掉了许多的情况，这里我们就来详细地学习学习，这里还是以“一个店只能有一个老板”为例，创建老板类单例。 1，常规实现方式 (1) 饿汉式 这个就是上一篇博客讲的方法，也是最简单的实现方法： package com.example.sin..
java 单例模式getInstance()
MrYin的博客
06-14 3026
//使用实例，在定义的新类当中加入getInstance()方法，返回值即为该类的一个对象，此方法常常应用在Java的单例模式当中 public class Lvbudong { private Lvbudong(){ } public static synchronized Lvbudong getInstance(){ if(instance == null) ...
java 单例模式及getInstance的好处
weixin_30673715的博客
02-16 215
1、什么是单例模式 　　简单理解为，有一个类，只能有一个实例化对象，这就是单例模式。 2、getInstance的好处 　　首先看一下怎样使用getInstance实现单例模式public class ConnectionPool { private static ConnectionPool pool; //其他成员变量 //……public static syn...
java static 单例_实现单例模式的两种方法（static final对象、getInstance）
weixin_39541767的博客
02-24 289
[java]代码库//使用第一种方式的单例模式类，通过公共属性来创建对象public class SingletonDemo2 {//第一种实现单例模式的方法，通过公共属性来实现实例化//声明一个公共的静态属性，使只被实例化一次public static final SingletonDemo2 singletonDemo = new SingletonDemo2();//声明一个私有的构造方法，...
Java类的单例模式_Java自学-类和对象 单例模式
weixin_33665771的博客
02-15 113
Java的饿汉式与懒汉式单例模式LOL里有一个怪叫大龙GiantDragon，只有一只，所以该类，只能被实例化一次步骤 1 : 单例模式单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。步骤 2 : 饿汉式单例模式GiantDragon 应该只有一只，通过私有化其构造方法，使得外部无法通过new 得到新的实例。 GiantDragon 提供了一个public...
Java 单例模式
kiss_vicente的专栏
08-24 1211
Java Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。   我们在浏览BBS、SNS网站的
图解 java 设计模式（二）——彻底弄明白单例模式，工厂模式
qq_42279295的博客
11-20 4379
1、图解 java 设计模式（二）——彻底弄明白单例模式，工厂模式 1.1、前言 大家可以去 b 站观看韩老师的视频：b站韩老师视频链接 1.2、设计模式介绍 1.2.1、基本介绍 设计模式是程序员在面对同类软件设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案，设计模式（Design Pattern）代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的时间的试验和错误总结出来的。 设计模式的本质提高 软件的维护性，通用性和扩展性，并降低软件的复杂度。 设计模式的本质提高 软
手撕单例模式——彻底搞懂饿汉式、懒汉式、静态内部类、枚举实现单例，以及通过反射和反序列化破坏单例
weixin_44340573的博客
10-02 612
单例模式的实现主要可以通过饿汉式、懒汉式（DCL）、静态内部类以及枚举实现。 其中饿汉式、懒汉式、静态内部类皆可以通过反射或序列化的方式破坏单例，而枚举可以有效的防止反射破坏单例。 注意：单例中的构造是私有的，只有私有构造器才能防止外部类轻易通过构造方法来创建实例，从而破坏单例。 饿汉式单例模式 所谓饿汉式就是直接在实例初始化时，便调用构造方法来创建单例。 public class Hungry { private Hungry(){ } private final static
阿里java面试官问：写一个你认为最好的单例模式？怒写了7个
Java高级教程、Java架构师、Java进阶教程
04-25 389
面试题：写一个你认为最好的单例模式 面试考察点 考察目的： 单例模式可以考察非常多的基础知识，因此对于这种问题，很多面试官都会问。 小伙伴要注意，在面试过程中，但凡能够从多个维度考察求职者能力的题目，一定不会被抛弃，特别是比较泛的问题，比如： ”请你说说对xxx的理解“之类。 考察范围： 工作1到5年经验，随着经验的提升，对于该问题的考察深度越深。 好友添加：huany6880 加入资深Java学习交流圈，并有系统整理了一套java初学/进阶者最佳的学习方法以及路 线图大纲，Java各核心知识点、架构.
超详细Java入门到精通自学视频课程-07、static：应用知识-单例模式.rar
08-31
Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。 使用Java编写的应用程序，既可以在一台单独的电脑上运行，也可以被分布在一个网络的...
Java 中单例模式的正确用法？
Thomas.Sir’s Article
03-14 690
单例模式指的是，保证一个类只有一个实例，并且提供一个全局可以访问的入口。 那么我们为什么需要单例呢，其中一个理由，那就是为了节省内存、节省计算。很多情况下，我们只需要一个实例就够了，如果出现了更多的实例，反而属于浪费。举个例子： public class ExpensiveResource { public ExpensiveResource() { field1 = // 查询数据库 field2 = // 然后对查到的数据做大量计算 fiel
Java 代码块及单例模式
weixin_59661960的博客
07-25 345
java 代码块，单例模式
最新JAVA设计模式——单例模式八种方式，真香定律
最新发布
2401_84003839的博客
05-14 959
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）最新整理电子书本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取高系统性能针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。
对象的构造方法以及单例模式
weixin_53379153的博客
05-31 234
以一个User类来进行举例，说明对象的不同创造方法。 格式：以类名作为方法的名字。 每一个类都具有一个隐藏的空参数构造方法，在显式的写了构造方法之后会被覆盖掉。 构造方法是：创建对象时调用的（对于每个对象，构造方法只能执行一次）构造方法也可以自己添加参数，在创建对象的时候直接将参数进行初始化。 可以通过set，get，is等方法进行初始化。 如： public class User { private String name; private int age; priv
java单例模式的7种实现方式
冰封骑士的专栏
12-28 387
1.懒汉式加载，最简单的单例模式，只需要2两步， a.把自己的构造方法设置为私有的，不让别人访问你的实例，b.提供一个static方法给别人获取你的实例 public class Singleton{ private static Singleton singleton; private Singleton(){ } public static S...
单例模式及getInstance()的用法（转）
YUNWEISAN的博客
08-03 1623
介绍 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。 这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 单例类只能有一个实例 单例类必须自己创建自己的唯一实例 单例类必须给所有其他对象提供这一类 意图：当我们想要一个类在系统操作运行时只有一个实例时，可以采用单例模式。...
java中的getinstance_java基础---Java中的getInstance
weixin_32151313的博客
02-13 1969
版权声明：本文为CSDN博主「OutThink」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/OutThink/article/details/76464959在写getInstance之前先写一下单例模式单例模式Java中单例模式是一种常见的设计模式，单例模式有以下特点：1、单例类只能有一个实例。2、单...
单例模式的三种实现 HungrySingleton（饿汉式） LazySingleton1（懒汉式：方法级锁） LazySingleton2（懒汉式：双检查锁 有BUG）
liuchina的专栏
05-27 1453
<br />以下包含三种单例模式的实现。<br />1 HungrySingleton（饿汉式） <br />2 LazySingleton1（懒汉式：方法级锁） <br />3 LazySingleton2（懒汉式：双检查锁 有BUG）<br />其中第三种在有的JAVA平台内存模型中，可能会出现BUG，不推荐使用<br />参考文章 双重检查锁定及单例模式 Peter Haggar<br />package singletonPattern;<br />/**<br /> * describe: 饿汉式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值