单例模式之懒汉式

已于 2023-05-09 17:19:03 修改
阅读量2.3k 收藏 8
点赞数 5
分类专栏： Java并发编程 文章标签： 单例模式
于 2023-03-10 15:41:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ganmaotong/article/details/129420249
版权

       在上篇文章中，我们讲了单例模式中的饿汉式，今天接着来讲懒汉式。

1.懒汉式单例模式的实现

public class LazySingleton {

    private static LazySingleton instance = null;

    // 让构造函数为private，这样该类就不会被实例化
    private LazySingleton() {
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }

    public long getRamAddress() {
        return this.hashCode();
    }
}

      懒汉式的特点在于有需要时才实例化。

2.懒汉式线程安全

      在多线程的环境下，getInstance方法会导致线程不安全。因为在getInstance时，可能A、B两个线程几乎同时进入，在A实例化未完成的情况下，B判断实例仍然为null，因此继续实例化，这样有实例化了两个不同的对象，明显违背了单例的初衷。这里可以稍微验证一下线程安全问题，为了方便验证，在getInstance让当前线程sleep：

    public static LazySingleton getInstance() {
        if (instance == null) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new LazySingleton();
        }
        return instance;
    }

       测试代码：

      /**
     * 公共方法，在多线程环境下测试单例，避免重复编写测试代码
     * @param threadCount 线程数
     * @param func        函数，用于获取单例
     * @param <T>
     */
    public static <T> void singLetonMultiThread(int threadCount, Supplier<T> func) {
        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
        IntStream.range(0, threadCount).forEach(i -> {
            executorService.submit(() -> {
                System.out.println(func.get());
            });
        });

        // 等线程全部执行完后关闭线程池
        executorService.shutdown();
        try {
            executorService.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void lazySingLetonTest() {
        Supplier func = () -> LazySingleton.getInstance();
        singLetonMultiThread(10, func);
    }

测试结果如下：

  

       十个线程里出现了8个不同的对象！

2.1 双重检查锁

      我们需要改进一下getInstance方法，考虑到效率问题，我们不想直接在getInstance方法上加锁，因为这种方式下每次调用getInstance()时都需要进行线程锁定判断，在多线程高并发访问环境中，将会导致系统性能大大降低。于是，我们得在判断实例是否为空时加锁，并且进行双重检查：

    public static LazySingleton getInstance() {
        if (instance == null) {
            synchronized (LazySingleton.class) {
                // 这里需要再判断一次，因为可能有其它线程已经创建实例
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }

       这样看起来似乎是解决了问题了。

2.2 指令重排

       但这还有瑕疵。对于：

instance = new LazySingleton();

       这个创建对象的语句其实是个非原子操作，在极端的多线程环境下，会存在安全问题。对象的创建过程，在执行的时候分解成以下三条指令：

memory=allocate(); 			//1.分配对象的内存空间
ctorInstance(memory);       //2.执行构造方法来初始化对象
instance=memory;			//3.设置instance指向刚分配的内存地址

       正常执行顺序应该是1->2->3，但可能指令会被重排序为1->3->2，也就是说，2、3步有可能发生指令重排导致重排序，因为synchronized只能保证有序性，但无法禁止指令重排。假设有两个线程A、B，在双重检查锁内，从cpu时间片上的执行顺序如下：

       A线程执行完3还没执行2，虽然分配了内存空间已，但是还没初始化对象，而此时B线程进来判断(instance == null)，由于instance已经指向了内存空间，所以instance != null，于是直接返回了对象，但此时对象还未初始化。这样一来，线程B将得到一个还没有被初始化的对象。

       为了防止指令重排，需在声明instance对象时加上volatile关键词：

public class LazySingleton {

    // volatile，确保本条指令不会因编译器的优化而省略，且要求每次直接读值
    private static volatile LazySingleton instance = null;

    // 让构造函数为private，这样该类就不会被实例化
    private LazySingleton() {
        //System.out.println("懒汉式单例初始化！");
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            synchronized (LazySingleton.class) {
                // 这里需要再判断一次，因为可能有其它线程已经创建实例
                if (instance == null) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }

    public long getRamAddress() {
        return this.hashCode();
    }
}

        volatile关键词具备以下功能:
       1. 避免编译器将变量缓存在寄存器里 
       2. 避免编译器调整代码执行的顺序 

       使用volatile声明的变量可以强制屏蔽编译器和JIT的优化工作，能够防止双重检查锁的指令重排。

3.反射破坏单例

      正如在上篇文章饿汉式单例中所说的那样，懒汉式同样有反射的问题。我们采用跟懒汉式一样的方法常识防止破坏单例：

public class LazySingleton {

    private static volatile LazySingleton instance = null;

    // 让构造函数为private，这样该类就不会被实例化
    private LazySingleton() {
        //System.out.println("懒汉式单例初始化！");
        synchronized (LazySingleton.class) {
            if(instance != null){
                throw new RuntimeException("单例构造器禁止反射调用");
            }
        }
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            synchronized (LazySingleton.class) {
                // 这里需要再判断一次，因为可能有其它线程已经创建实例
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }

    public long getRamAddress() {
        return this.hashCode();
    }
}

      再测试一下看看：

    public static void LazySingletonReflectionTest() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<LazySingleton> clazz = LazySingleton.class;
        // 获取HungrySingLeton的默认构造函数
        Constructor<LazySingleton> constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        // 调用默认构造函数创建实例
        LazySingleton h1 = constructor.newInstance();
        LazySingleton h2 = constructor.newInstance();
        System.out.println(h1.getRamAddress());
        System.out.println(h2.getRamAddress());
    }

      运行结果：

      没用！因为在类加载的时候，懒汉式单例根本就没有对单例进行初始化，然后反射通过构造函数获取单例，获取的对象都是不同的，所以没法防止反射破坏。当然，如果是先通过getInstance获取单例，再反射，这种情况下就可以防止反射，如：

    public static void reflectionTest2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        LazySingleton h0 = LazySingleton.getInstance();
        Class<LazySingleton> clazz = (Class<LazySingleton>) h0.getClass();
        // 获取HungrySingLeton的默认构造函数
        Constructor<LazySingleton> constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        // 调用默认构造函数创建实例
        LazySingleton h1 = constructor.newInstance();
        System.out.println(h0.getRamAddress());
        System.out.println(h1.getRamAddress());
    }

      懒汉式单例对这个问题没有好的解决办法。

4.优雅的单例实现——枚举

      单例模式存在线程安全、反射、序列化漏洞的问题，虽然可以想办法解决，但代码也比较臃肿了。换个角度，可以用枚举来实现，去规避这些问题。

public enum Singleton {

    INSTANCE;

    public void doSomething() {
        System.out.println("这里实现自己的业务");
    }
}

4.1 枚举单例防止反射

       先测试一下枚举单例的反射：

    public static void enumSingletonRlectionTest() throws NoSuchMethodException,
            IllegalAccessException, InvocationTargetException, InstantiationException {
        Singleton instance1 = Singleton.INSTANCE;
        Constructor<Singleton> declaredConstructor = Singleton.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        //java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.<init>()
        Singleton instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }

       结果抛出异常 ，没有构造函数Singleton.<init>()：

       这并非防止了反射。枚举Enum是个抽象类，它有个构造函数：

protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

       我们定义了枚举类单例，实际上就是继承了Enum，所以会有（String.class,int.class）的构造器，测试方法改造下：

    public static void enumSingletonRlectionTest() throws NoSuchMethodException,
            IllegalAccessException, InvocationTargetException, InstantiationException {
        Singleton instance1 = Singleton.INSTANCE;
        Constructor<Singleton> declaredConstructor = Singleton.class.
                getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        //java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.<init>()
        Singleton instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }

       结果如下：

       Cannot reflectively create enum objects(无法以反射方式创建枚举对象)，可以防止反射，因为反射在通过构造函数的newInstance方法创建对象时，会检查该类是否ENUM修饰，如果是则抛出异常，反射失败。所以枚举类不能通过反射来创建对象

4.2 枚举单例避免序列化问题

       普通的Java类的反序列化过程中，会通过反射调用类的默认构造函数来初始化对象。所以，即使单例中构造函数是私有的，也会被反射给破坏掉。由于反序列化后的对象是重新new出来的，所以这就破坏了单例，必须新增readResolve方法才能防止破坏。

       但是，枚举的反序列化并不是通过反射实现的。在序列化时，Java仅仅是将枚举对象的name属性输出到结果中，反序列化时则通过java.lang.Enum的valueOf(String name) 方法，根据名字查找内存中是否已经有该对象，若找到了就会直接使用它，如果不存在就会抛出异常。同时。编译器不允许任何对这种序列化机制的定制，因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。这样一来，序列化的方式就无法创建新的对象了，也就不会发生由于反序列化导致的单例破坏问题。

        实际测试一下：

    public static void enumSingletonSerializable() {
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            File file = new File("d:\\Singleton.txt");
            // -----------序列化-------------
            // 创建输出流
            oos = new ObjectOutputStream(new FileOutputStream(file));
            //将单例对象写到文件中  序列化
            oos.writeObject(Singleton.INSTANCE);
            oos.flush();

            // -----------反序列化-------------
            // 从文件读取单例对象
            ois = new ObjectInputStream(new FileInputStream(file));
            // 反序列化得到对象singLeton
            Singleton singLeton= (Singleton)ois.readObject();
            System.out.println(singLeton == Singleton.INSTANCE); //false
            file.deleteOnExit();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if(oos != null) {
                    oos.close();
                }
                if(ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

     

       测试结果：

4.3 多线程安全

       当我们使用enmu来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类，所以枚举类型不能被继承；同时，编译器所创建的类中，属性和方法也都是都是static类型的，因为static类型的属性会在类被加载之后被初始化。当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的（因为虚拟机在加载枚举的类的时候，会使用ClassLoader的loadClass方法，而这个方法使用同步代码块保证了线程安全）。所以，创建一个enum类型是线程安全的。所以，创建一个enum类型是线程安全的。

       基于前面的分析，单例类的线程安全问题，主要就是单例初始化过程中的线程安全问题。而由于枚举的以上特性，枚举实现的单例是天生线程安全的。所以用枚举实现的单例是最好的方式！

参考文章：

两种单例模式详解（内含懒汉式的双重校验锁详解）
为什么我墙裂建议大家使用枚举来实现单例

深度分析Java的枚举类型—-枚举的线程安全性及序列化问题

叶大师2018
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单例模式（饿汉式VS懒汉式）
qq_50233116的博客
05-29 827
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法
单例模式之懒汉式单例模式
jl19960421的博客
03-20 5106
单例模式之懒汉式单例模式 本文将探讨三种懒汉式单例模式，会从代码的运行效率，线程安全等方面探讨。 在上一篇文章中，刚刚介绍饿汉式单例模式，在本文开头先简单的说一下懒汉式单例模式和饿汉式单例模式的区别: 首先懒汉式单例模式，是在程序需要用到该实例时才会创建的。这样就不会像饿汉式一样，在类加载过程中就会创建。这样就减少了内存的浪费，当然也自然而然的带来了一些缺点：需要时才创建，影响程序的执行效率。另外，懒汉式单例模式在使用时进行创建，势必会带来线程安全的问题，需要解决以上问题，就需要用到锁。锁的使用也在一定程度
24种设计模式之单例模式（饿汉式、懒汉式）
inexaustible的博客
01-31 1万+
24种设计模式之单例模式（饿汉式、懒汉式）
饿汉单例、懒汉单例类
Anning1031的博客
03-30 351
饿汉单例、懒汉单例类
C# 单例模式--懒汉(双重验证、禁止指令重排、多线程)
廷益_飞鸟的博客
05-16 635
C# 单例模式–懒汉 代码：SingletonLazy.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; namespace SingletonLazy { // 单例模式 public class Singleton { #r
单例模式：二-懒汉模式（Lazy）
ciaty40822的专栏
07-30 588
原文： Gerrard_Feng 二：2-懒汉模式（Lazy） 思想：相比于饿汉模式，懒汉模式实际中的应用更多，因为在系统中，“被用到时再初始化”是更佳的解决方案。 　　设计思想与饿汉模式类似，同样是持有一个自身的引用，只是将 new 的动作延迟到 getinstance() 方法中执行...
java 单例模式（懒汉式与饿汉式）
08-29
Java 单例模式（懒汉式与饿汉式） Java 单例模式是一种常用的软件设计模式，在它的可信结构中只包含一个被实例化单例的特殊类。通过单例设计模式可以把整系统中的一个类只有一个实例。单例设计模式又分为两种方式，...
java + 单例模式 + 懒汉式 + 资源
12-21
在Java中，单例模式有多种实现方式，其中最常用的两种是饿汉式（Eager Initialization）和懒汉式（Lazy Initialization）。本文将深入探讨懒汉式单例模式，以及它与饿汉式的区别。 ### 懒汉式单例模式 懒汉式的...
计算机后端-Java-Java核心基础-第20章 多线程 11. 线程安全的单例模式之懒汉式.avi
05-22
计算机后端-Java-Java核心基础-第20章 多线程 11. 线程安全的单例模式之懒汉式.avi
老生常谈C++的单例模式与线程安全单例模式(懒汉/饿汉)
08-31
在C++编程中，单例模式是一种设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。这种模式常用于管理共享资源，如数据库连接、配置对象等。本文将讨论两种常见的单例实现方式：懒汉式和饿汉式，以及它们...
单例模式【懒汉模式】
03-06
懒汉模式是一种思想，是一种开发程序的规范
完美解决单例设计模式中懒汉式线程安全的问题
08-31
当多个线程同时调用 `getInstance()` 并且 `s` 为 `null` 时，每个线程都可能创建一个新的 `SingleDemo` 实例，导致多个实例存在，这违反了单例模式的基本原则。运行结果中的不同哈希值表示不同的对象实例，证明了这...
单例模式懒汉式和饿汉式区别
热门推荐
Harry的博客
04-11 9万+
单例模式懒汉式和饿汉式区别 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例...
单例模式(懒汉式和饿汉式)
sinat_36695865的博客
02-02 2005
package com.jason.singleton1; /** * @author jason * @Description:单例模式 懒汉式只有初始化的时候才会初始化对象 * @date 2018/2/2 */ public class Singleton { //1.私有化构造器 private Singleton(){ } //2.提供唯一的
单例设计模式及懒汉式线程安全问题解决方法
qq_34412985的博客
05-08 623
1.饿汉式：急切 public class Singleton｛ private static Singleton singleton = new Singleton();//private保证不能被外部修改 static保证实例只有一个 private Singleton(){};//保证不能被外部类实例化 public Singleton getInstance(){ retu...
单例模式--Lazy & UnLazy
villare的博客
10-04 1599
单例模式–Lazy & UnLazy1.Lazy实现方式 1.1 一般方式 1.2 Synchronized方式 1.3 静态内部类 2.UnLazy实现方式单例模式 1.单例类只有一个实例 2.单例类的唯一一个实例由自己创建 3.单例类的唯一一个实例能提供给其他外部内单例模式一般运用在实例对象初始化费时或者只需要一个的情况，如logger,printer等；Lazy 一般方式类中
单例模式的七种写法, 面试题：线程安全的单例模式
liangxw1的专栏
05-09 1万+
http://cantellow.iteye.com/blog/838473 http://meizhi.iteye.com/blog/537563 转载请注明出处：http://cantellow.iteye.com/blog/838473   第一种（懒汉，线程不安全）：   Java代码   public class Singleto
C#中使用 Lazy＜T＞在WPF中实现单例模式
helldoger的博客
02-15 1425
Lazy是延迟对象，通过它可以延迟创建T对象，也就是说，虽然已经声明了对象，但是实际上只有在使用T对象的时候，才会去创建这个对象。 在WPF中, 公共方法 可以写在单独的一个类中, 各个viewmodel等需要的时候再去使用Lazy调用. 例如 建立公共类appData using GalaSoft.MvvmLight; using System; using System.Collections.Generic; using System.Linq; using System.Text; using Sy
3.单例模式之Lazy Initialization Holder Class模式
yj826299017的博客
03-25 1302
单例模式之Lazy Initialization Holder Class模式1.0 前面已经介绍过两种单例模式：饿汉式单例模式和懒汉式单例模式 点击前往单例模式之饿汉式单例模式 点击前往单例模式之懒汉式单例模式1.1本文的源码获取:点击下载(建议使用电脑下载,解压缩后将文件夹放入src即可)1.2代码场景:A、package内有AppConfig.properties文件。B、通过获取单例的Ap...
懒汉式单例模式和饿汉式单例模式的异同
最新发布
11-19
以下是懒汉式单例模式和饿汉式单例模式的异同： 相同点： 1. 都是单例模式，即保证一个类只有一个实例对象。 2. 都使用了私有的构造函数，防止外部创建实例对象。 3. 都使用了静态变量来保存实例对象。 不同点： 1. 创建对象的时机不同：饿汉式在类加载时就创建了对象实例，而懒汉式是在使用时才创建。 2. 线程安全性不同：饿汉式天生是线程安全的，因为在类加载时就已经创建了对象实例，而懒汉式需要考虑线程安全问题，可以使用synchronized关键字或者双重检查锁定等方式来保证线程安全。 3. 性能不同：饿汉式在类加载时就创建了对象实例，所以在访问速度和反应时间上都比懒汉式快，但是如果这个实例一直没有被使用，那么就会造成内存浪费。而懒汉式只有在使用时才会创建对象实例，所以在内存占用上比饿汉式要低，但是在访问速度和反应时间上会稍微慢一些。 下面是懒汉式单例模式的示例代码： ```python class Singleton: __instance = None def __init__(self): if Singleton.__instance != None: raise Exception("该类已经实例化过了") else: Singleton.__instance = self @staticmethod def getInstance(): if Singleton.__instance == None: Singleton() return Singleton.__instance ``` 下面是饿汉式单例模式的示例代码： ```python class Singleton: __instance = Singleton() def __init__(self): if Singleton.__instance != None: raise Exception("该类已经实例化过了") else: Singleton.__instance = self @staticmethod def getInstance(): return Singleton.__instance ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值