【J2SE】为什么静态内部类的单例可以实现延迟加载

最新推荐文章于 2025-10-06 01:53:17 发布
原创 最新推荐文章于 2025-10-06 01:53:17 发布 · 8k 阅读 · 27 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#单例 #类加载 #延迟初始化 #静态内部类单例

本文探讨了静态内部类实现单例模式的优势，解释了其如何实现延迟加载，避免了线程安全问题和不必要的内存占用。通过分析类加载时机、字节码常量池解析，揭示了静态内部类单例在运行时才进行方法调用和符号引用解析，从而实现延迟加载。静态内部类单例是一种兼顾性能和安全的实现方式。

一、单例

单例是一个常见的设计模式，常见有四种方式来实现，即懒汉式、饿汉式、枚举和静态内部类实现，这个模式的本质是为了控制内存中某个类的实例数量。

  1. 懒汉式采用懒加载，时间换空间，因此需要注意获取实例时的并发安全问题，即便正确并发，每次获取实例的时候还是要浪费一次判断；
  2. 饿汉式空间换时间，在定义单例对象时就完成实例化，因为JVM在初始化一个类的时候（即调用类构造函数<clinit>()）会自动同步（饿汉式的单例对象必须用static修饰，否则会StackOverFlowError），因此不用关心线程安全问题，但是一旦完成类加载过程，无论是否使用该单例，该单例都已经实际占用内存；
  3. 枚举可以做天然的单例，枚举的思想本质就是该类的实例可以穷举，像季节、性别这种实例可以穷举的类型，然而枚举和饿汉式有一样的缺点，只要加载无论是否使用单例，都会占用内存，但是枚举的构造函数通过反射获取到以后再newInstance是非法的（见例一），因此枚举实现的单例相较之懒汉式和饿汉式，无需在私有的构造函数中再进行单例的判断从而控制构造函数被非法反射调用，即在私有构造函数中省略了if(instance != null){抛异常}。

至于单例类是否需要对反序列化进行控制的问题，一般单例类都是作为工具类来使用，不需要序列化，因此不需要实现java.io.Serializable接口；特殊情况下，如果单例类实现了序列化接口，只需要再readResolve方法中返回单例即可。

静态内部类实现单例，一是解决了懒加载线程安全问题（静态内部类实现单例，单利对象static修饰，所以不需要像懒加载在做null判断的时候进行同步，而是在类加载的第三个步骤初始化时由JVM自动同步）和获取单例时的判断问题；二是解决了饿汉式和枚举在加载时无论是否使用就分配内存的问题；三是可以和懒加载、饿汉式一样通过在私有构造中判断单例是否为null来进行非法构造方法反射的控制。

因此，静态内部类来实现单例，是相对较好的一种方式。需要提醒的是，本文是想深入讨论为什么性能好，在实际写项目的时候，大可不必吹毛求疵的追逐性能。

例一 枚举构造函数反射获取后调用newInstance非法

package cn.okc.demo;

public enum Gender {
	MALE, FEMALE;
}
package cn.okc.demo;

import java.lang.reflect.Constructor;

public class TestGender {
	public static void main(String[] args) throws Exception {
		Class<Gender> clazz = Gender.class;
		@SuppressWarnings("unchecked")
		Constructor<Gender>[] constructors = (Constructor<Gender>[]) clazz.getDeclaredConstructors();
		for (Constructor<Gender> c : constructors)
			System.out.println(c);

		Constructor<Gender> constructor = clazz.getDeclaredConstructor(String.class, int.class);
		constructor.setAccessible(true);
		Gender gender = constructor.newInstance("MALE", 0);
		System.out.println(gender);
	}
}
private cn.okc.demo.Gender(java.lang.String,int)
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
	at cn.wxy.demo.TestGender.main(TestGender.java:15)

 

二、静态内部类实现单例及延迟加载验证测试

例二 静态内部类实现单例示例代码

package cn.okc.demo;

public class Singleton {
	// 静态内部类实现单例
	private static class Inner {
		// 单例对象
		private static Singleton singleton = new Singleton();
		// 类加载分为加载、链接、初始化三大步骤
		// 其中链接又分为验证、准备和解析三小个步骤
		// 类中静态的内容在编译阶段都会被编译到类构造函数<clinit>()中，在初始化步骤调用
		// 因此这个代码块的调用标志着内部类被初始化了
		static {
			System.out.println("内部类被解析了");
		}
	}

	// 私有化构造函数
	private Singleton() {
		// 判断单例对象是否已经存在，用于控制非法反射单例类的构造函数
		if (Inner.singleton != null)
			try {
				throw new IllegalAccessException("单例对象已经被实例化，请不要非法反射构造函数");
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
	}

	// 合法获取单例对象的途径
	public static Singleton getInstance() {
		return Inner.singleton;
	}
}

例三 延迟加载测试（HotSpot）

-----------------------------------------------------------------------------------------------------------------------------

如例三所示，外部类被成功加载并初始化，此时并未导致内部类也跟着被初始化，如果内部类被初始化，则内部类的静态块会被执行并输出。

 

三、详解

为什么静态内部类单例可以实现延迟加载？实际上是外部类被加载时内部类并不需要立即加载内部类，内部类不被加载则不需要进行类初始化，因此单例对象在外部类被加载了以后不占用内存。

实际上，无论是外部类还是静态内部类，对JVM而言，他们是平等的两个InstanceClass对象，只存在访问修饰符限制访问权限的问题，不存在谁包含谁的问题。

从字节码来窥探静态内部类单例延迟加载，需要从类加载的时机和字节码常量池解析的时机两个方面来得到答案。

1. 窥探字节码

例四 外部类字节码

Classfile /D:/dev_code/workspace_neon/jdbc/target/classes/cn/okc/demo/Singleton.class
  Last modified 2016-10-20; size 856 bytes
  MD5 checksum 845fd5779231adacc4cebe26f2515a66
  Compiled from "Singleton.java"
public class cn.wxy.demo.Singleton
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Class              #2             // cn/wxy/demo/Singleton
   #2 = Utf8               cn/wxy/demo/Singleton
   #3 = Class              #4             // java/lang/Object
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Methodref          #3.#9          // java/lang/Object."<init>":()V
   #9 = NameAndType        #5:#6          // "<init>":()V
  #10 = Methodref          #11.#13        // cn/wxy/demo/Singleton$Inner.access$0:()Lcn/wxy/demo/Singleton;
  #11 = Class              #12            // cn/wxy/demo/Singleton$Inner
  #12 = Utf8               cn/wxy/demo/Singleton$Inner
  #13 = NameAndType        #14:#15        // access$0:()Lcn/wxy/demo/Singleton;
  #14 = Utf8               access$0
  #15 = Utf8               ()Lcn/wxy/demo/Singleton;
  #16 = Class              #17            // java/lang/IllegalAccessException
  #17 = Utf8               java/lang/IllegalAccessException
  #18 = String             #19            // 单例对象已经被实例化，请不要非法反射构造函数
  #19 = Utf8               单例对象已经被实例化，请不要非法反射构造函数
  #20 = Methodref          #16.#21        // java/lang/IllegalAccessException."<init>":(Ljava/lang/String;)V
  #21 = NameAndType        #5:#22         // "<init>":(Ljava/lang/String;)V
  #22 = Utf8               (Ljava/lang/String;)V
  #23 = Methodref          #16.#24        // java/lang/IllegalAccessException.printStackTrace:()V
  #24 = NameAndType        #25:#6         // printStackTrace:()V
  #25 = Utf8               printStackTrace
  #26 = Utf8               LineNumberTable
  #27 = Utf8               LocalVariableTable
  #28 = Utf8               this
  #29 = Utf8               Lcn/wxy/demo/Singleton;
  #30 = Utf8               e
  #31 = Utf8               Ljava/lang/IllegalAccessException;
  #32 = Utf8               StackMapTable
  #33 = Utf8               getInstance
  #34 = Utf8               (Lcn/wxy/demo/Singleton;)V
  #35 = Methodref          #1.#9          // cn/wxy/demo/Singleton."<init>":()V
  #36 = Utf8               SourceFile
  #37 = Utf8               Singleton.java
  #38 = Utf8               InnerClasses
  #39 = Utf8               Inner
{
  public static cn.wxy.demo.Singleton getInstance();
    descriptor: ()Lcn/wxy/demo/Singleton;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: invokestatic  #10                 // Method cn/wxy/demo/Singleton$Inner.access$0:()Lcn/wxy/demo/Singleton;
         3: areturn
      LineNumberTable:
        line 30: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature

  cn.wxy.demo.Singleton(cn.wxy.demo.Singleton);
    descriptor: (Lcn/wxy/demo/Singleton;)V
    flags: ACC_SYNTHETIC
    Code:
      stack=1, locals=2, args_size=2
         0: aload_0
         1: invokespecial #35                 // Method "<init>":()V
         4: return
      LineNumberTable:
        line 18: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
}
SourceFile: "Singleton.java"

例五 静态内部类字节码

Classfile /D:/dev_code/workspace_neon/jdbc/target/classes/cn/wxy/demo/Singleton$Inner.class
  Last modified 2016-10-20; size 772 bytes
  MD5 checksum 87afaa7bf2981e8a99d143ee3e01054f
  Compiled from "Singleton.java"
class cn.wxy.demo.Singleton$Inner
  minor version: 0
  major version: 52
  flags: ACC_SUPER
Constant pool:
   #1 = Class              #2             // cn/wxy/demo/Singleton$Inner
   #2 = Utf8               cn/wxy/demo/Singleton$Inner
   #3 = Class              #4             // java/lang/Object
   #4 = Utf8               java/lang/Object
   #5 = Utf8               singleton
   #6 = Utf8               Lcn/wxy/demo/Singleton;
   #7 = Utf8               <clinit>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Class              #11            // cn/wxy/demo/Singleton
  #11 = Utf8               cn/wxy/demo/Singleton
  #12 = Methodref          #10.#13        // cn/wxy/demo/Singleton."<init>":(Lcn/wxy/demo/Singleton;)V
  #13 = NameAndType        #14:#15        // "<init>":(Lcn/wxy/demo/Singleton;)V
  #14 = Utf8               <init>
  #15 = Utf8               (Lcn/wxy/demo/Singleton;)V
  #16 = Fieldref           #1.#17         // cn/wxy/demo/Singleton$Inner.singleton:Lcn/wxy/demo/Singleton;
  #17 = NameAndType        #5:#6          // singleton:Lcn/wxy/demo/Singleton;
  #18 = Fieldref           #19.#21        // java/lang/System.out:Ljava/io/PrintStream;
  #19 = Class              #20            // java/lang/System
  #20 = Utf8               java/lang/System
  #21 = NameAndType        #22:#23        // out:Ljava/io/PrintStream;
  #22 = Utf8               out
  #23 = Utf8               Ljava/io/PrintStream;
  #24 = String             #25            // 被解析了
  #25 = Utf8               被解析了
  #26 = Methodref          #27.#29        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #27 = Class              #28            // java/io/PrintStream
  #28 = Utf8               java/io/PrintStream
  #29 = NameAndType        #30:#31        // println:(Ljava/lang/String;)V
  #30 = Utf8               println
  #31 = Utf8               (Ljava/lang/String;)V
  #32 = Utf8               LineNumberTable
  #33 = Utf8               LocalVariableTable
  #34 = Methodref          #3.#35         // java/lang/Object."<init>":()V
  #35 = NameAndType        #14:#8         // "<init>":()V
  #36 = Utf8               this
  #37 = Utf8               Lcn/wxy/demo/Singleton$Inner;
  #38 = Utf8               access$0
  #39 = Utf8               ()Lcn/wxy/demo/Singleton;
  #40 = Utf8               SourceFile
  #41 = Utf8               Singleton.java
  #42 = Utf8               InnerClasses
  #43 = Utf8               Inner
{
  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=3, locals=0, args_size=0
         0: new           #10                 // class cn/wxy/demo/Singleton
         3: dup
         4: aconst_null
         5: invokespecial #12                 // Method cn/wxy/demo/Singleton."<init>":(Lcn/wxy/demo/Singleton;)V
         8: putstatic     #16                 // Field singleton:Lcn/wxy/demo/Singleton;
        11: getstatic     #18                 // Field java/lang/System.out:Ljava/io/PrintStream;
        14: ldc           #24                 // String 被解析了
        16: invokevirtual #26                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        19: return
      LineNumberTable:
        line 7: 0
        line 13: 11
        line 14: 19
      LocalVariableTable:
        Start  Length  Slot  Name   Signature

  static cn.wxy.demo.Singleton access$0();
    descriptor: ()Lcn/wxy/demo/Singleton;
    flags: ACC_STATIC, ACC_SYNTHETIC
    Code:
      stack=1, locals=0, args_size=0
         0: getstatic     #16                 // Field singleton:Lcn/wxy/demo/Singleton;
         3: areturn
      LineNumberTable:
        line 7: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
}
SourceFile: "Singleton.java"

2. 类加载的时机和字节码常量池解析的时机

弄清楚什么时候加载一个类，才能弄清楚什么时候静态内部类会被加载。

这部分参考《深入理解java虚拟机》第七章和《java虚拟机规范》内容，其实主要关注例四外部类字节码第19行常量池中Methodref从符号引用解析成直接引用的时机，这个时机可以验证实在运行时，而不是在加载过程中；第55行，invokestatic（这个方法会导致类加载）调用内部类自动生成的方法例五75行access$0（见77行访问标识符ACC_SYNTHETIC，这个标识符表示内容不在原文件中，而是由虚拟机生成），但是这里要关注的是方法在运行被调用才会生成方法栈（参看《深入理解java虚拟机》第八章内容）。

简而言之：加载的时候方法不会被调用，不会触发外部类getInstance方法中invokestatic指令对内部类进行加载；加载的时候字节码常量池会被加入类的运行时常量池——其中类加载的解析步骤又叫常量池解析，主要是将常量池中的符号引用解析成直接引用，但是这个解析过程不一定非得在类加载时完成，可以延迟到运行时进行——这时候和静态内部类有关的Methodref符号解析会延迟到运行时；因此，静态内部类实现单例参会延迟加载。

后续有空再详细补充。。。。。。

 

四、参考资料

1. 《java虚拟机规范》

2. 《深入理解java虚拟机》

3. 《研磨设计模式》

4. 《HotSpot实战》

 

附注：

    本文如有错漏，烦请不吝指正，谢谢！

Android面试-Java基础
学无止境
10-17 1346
1. 九种基本数据类型的大小，以及他们的封装类。 java中有八种基本数据类型，int,double,long,float,short,byte,character,boolean,void;他们对应的封装类型是：Integer ,Double ,Long ,Float, Short,Byte,Character,Boolean,Void; 2. Switch能否用string做参数？ ...
黑马程序员入学Java知识——精华总结
u014563778的专栏
04-17 3886
黑马程序员入学Java知识——精华总结   J2SE部分，Java高新技术部分，7K面试题部分等黑马入学要求的知识点总结！   一、黑马程序员—java概述与基础知识 6 1、何为编程？ 6 2、Java语言概述，历史、特点 6 3、什么是跨平台性？原理是什么？JVM 7 4、Jre和Jdk的区别? 7 5、java虚拟机JVM 8 6、 Java程序运行机制 8 7
【JVM】为什么静态内部类实现单例模式是线程安全？
m0_73499047的博客
09-18 499
那么回到这个代码中，这里的静态变量的赋值操作进行编译之后实际上就是一个代码，当我们执行getInstance方法的时候，会导致SingleTonHolder类的加载，类加载的最后会执行类的初始化，但是即使在多线程情况下，这个类的初始化的代码也只会被执行一次，所以他只会有一个实例。（但是只有第一个获得锁的线程，会执行初始化，执行完之后会设置一个标志位，表示已经初始化完成，后面其他的线程再次获得锁，检查标志位，发现已经初始化完了，直接释放锁，不会再次执行初始化。
懒汉式单例模式（延时加载）
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
04-25 853
单例模式（Singleton Pattern）是一种对象创建型模式。 单例模式：确保一个类仅有一个实例，且自行实例化，并对外提供这个唯一的实例。 单例模式实现方式分为非延时加载（饿汉式 Eager Singleton）和 延时加载（懒汉式 Lazy Singleton），延时加载( 节省内存)可以有效提高系统资源的利用效率，所以通常使用延时加载的懒汉式实现
Java语言中静态内部类的加载时机与内存泄漏防范详解
最新发布
zhupeng0929的专栏
10-06 358
只有当程序首次主动访问静态内部类的静态成员（如静态字段、静态方法）或创建其实例时，才会触发JVM对该静态内部类进行加载、链接和初始化。例如，在Android中，非静态Handler内部类隐式持有Activity引用，若Handler消息未处理完，Activity无法销毁。静态内部类隐式持有对外部类实例的引用（当在非静态上下文中声明时），若不谨慎管理，可能导致内存泄漏。典型场景是长生命周期对象（如单例、线程池）持有了静态内部类实例，而该实例又隐式引用了短生命周期的外部类实例，阻止其被垃圾回收。
（小实验）“静态内部类”模式的“延迟加载”性质验证
DawdleD的博客
09-02 256
单例模式看似简单，实则蕴含着不少的编程知识点。相关材料声称，对比“饿汉”模式，’“静态内部类”模式更类似于“懒汉”模式，即外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。 首先给出“饿汉模式”和“静态内部类”的代码demo： 接下来，为了证明“静态内部类”确实存在延时加载之特性，我们需以妥当方式触发外部类的加载过程。为此我们需要回顾一下“主动引用”的触发条件： 最后需要写代码进行验证： ...
使用静态内部类实现延迟加载单例模式
一个执着的程序员
02-24 1万+
所谓单例模式，简单来说，就是在整个应用中保证只有一个类的实例存在。就像是Java Web中的application，也就是提供了一个全局变量。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类就称为单例类。 单例的创建一般分为懒汉式，恶汉式，双重锁检查，枚举等，其中双重锁检查只能在jdk1.5以后才能有效，1.5以前在java对象模型中的无序写问题不能保证。
静态内部类实现的单例如何做到线程安全且可延迟加载
m0_49595489的博客
09-01 285
通过调用 getInstance() 方法，可以获取到单例对象的实例。由于静态内部类只会被加载一次，因此可以保证线程安全。同时，由于静态内部类的加载是在调用 getInstance() 方法时才会进行，所以实现了延迟加载的效果。无参构造器只会运行一次。
2012年J2SE与Java面试题集锦
此外，Hibernate作为ORM框架，其缓存机制、延迟加载、Session生命周期管理也是考察重点。MyBatis则更偏向于灵活的SQL映射，面试中可能涉及XML配置、动态SQL、结果集映射等内容。 回到J2SE部分，具体的面试知识点...
JavaSE基础知识点整理总结
热门推荐
weixin_48444650的博客
08-02 1万+
目录一、Java语言概述二、程序设计基础1、标识符2、关键字3、常量、变量及作用域4、数据类型5、运算符与表达式6、流程控制结构7、方发初识三、数组1.数组2. 一维数组3. 二维数组4. 数组总结5. 数组排序(1) 冒泡排序(2)选择排序6. 数组元素查找(1). 顺序查找(2). 二分查找四、面向对象1. 面向对象介绍2. 类和对象3. 封装4. 继承5. 多态6. 抽象类与接口7. Object类8. 设计模式五、异常1. 概念2. 系统异常分类3. Error4. Exception5. 自定义异
javase学习笔记，学习时间一个月，发布笔记进度1/3
m0_60726300的博客
04-10 2168
1. Java基本语法 1.1 语言概述 1.1.1 整体语言概述 1.1.2 Java语言概述 1.1.2.1 基础常识 软件：即一系列按照特定顺序组织的计算机数据和指令集合。分为系统软件和应用软件 系统软件：Windows，mac os，linux，unix，android，ios，… 应用软件：word，ppt，画图板 人机交互方式：图形化界面vs命令行方式 应用程序=算法+数据结构 1.1.2.2 计算机语言的发展迭代史 第一代：机器语言 第二代：汇编语言 第三代：高级语言 面向过程：C，P
单例模式 之内部类延迟加载，（多）线程安全
默默不代表沉默
12-18 1023
单例模式，很多种方式实现，但是这儿只介绍最优方案。 就是利用内部类去实现单例模式。 这种单例模式的好处就是，延迟加载，减少内存开销，访问成本低且线程安全。 直接上代码： /** * @Author : JCccc * @CreateTime : 2018-11-5 * @Description : * @Point: Keep a good mood **/ public c...
java静态内部类延迟加载
weixin_38875721的博客
07-20 1428
package test3; public class Singleton { static{ System.out.println("Singleton 的静态块"); } { System.out.println("Singleton 的普通块"); } public static String name = "fdsfds"; private String nam...
静态内部类的延迟加载
远方的少年
03-26 583
之前在实现单例模式时可以基于静态内部类的方式来实现。静态内部类有延迟加载的作用。 public class OuterClass { static { System.out.println("Outer class load"); } static class InnerClass{ static { System.out.println("Inner class load");...
静态内部类实现的单例模式是如何保证线程安全的
yao_94的博客
09-18 6882
静态内部类实现的单例模式如下： public class Singleton {     private Singleton(){              }          public static Singleton getInstance(){         return SingletonHolder.sInstance;     }          private stati...
内部类、静态内部类-延迟加载
FightingITPanda的博客
01-09 751
外部类加载顺序： 1、外部类初次加载，会初始化静态变量、静态代码块、静态方法，但不会加载内部类和静态内部类。 2、实例化外部类，调用外部类的静态方法、静态变量，则外部类必须先进行加载，但只加载一次。 3、直接调用静态内部类时，外部类不会加载。 内部类加载顺序： 在初次调用的时候加载，且只加载一次 package com.panda; /** * author: ysd * Date: 202...
为什么静态内部类的单例模式是线程安全的？
ren421259121的博客
05-08 3091
public class Singleton { private Singleton() { } private static class SingletonHolder{ private static final Singleton singleton = new Singleton(); } public static Singleton getInstance(){...
单例模式：静态内部类实现的单例模式是懒加载且线程安全的
zckyyy0926的博客
04-16 957
由于加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。因此使用静态内部类实现的单例模式是懒加载的且线程安全。 一、代码 public class UserSingleton { /** 私有化构造器 */ private UserSingleton() { } /** 对外提供公共的访问...
自定义类加载器：单例热加载实现详解
本文档主要探讨了如何在Java中实现单个类实例的热加载，并介绍了Java体系结构的关键组成部分。首先，热加载是指在程序运行过程中动态加载类或类的修改，而无需重启整个应用。要实现这个功能，开发人员需要自定义一个...
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值