从内部静态类单例模式看类加载顺序

最新推荐文章于 2024-11-18 22:29:57 发布
原创 最新推荐文章于 2024-11-18 22:29:57 发布 · 281 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

博客介绍了外部调用PlayerSdkManager.getInstance()的流程，包括getInstance加载、PlayerSdkManager类加载及构造函数执行时的打印信息。还提及类加载顺序，即父类静态代码块、子类静态代码块等，且构造函数最后执行。

外部调用PlayerSdkManager.getInstance()：

1、getInstance被加载；“yiyiyi”打印

2、PlayerSdkManagerHolder被使用，因为是静态内部类，所以PlayerSdkManager类被加载；“hahaha”打印

3、sInstance被使用且是静态属性，第一调用，会执行 PlaySdkManager的构造函数。"lalala"打印

 

另外：

父类的静态代码块->子类的静态代码块->初始化父类的属性值/父类的普通代码块(自上而下的顺序排列)->父类的构造方法->初始化子类的属性值/子类的普通代码块(自上而下的顺序排列)->子类的构造方法。
注：构造函数最后执行。

 

内部类加载顺序及静态内部类单例模式
07-20 149
https://blog.csdn.net/zmx729618/article/details/69227762 加载一个类时，其内部类是否同时被加载？下面我们做一个实验来看一下。  Java代...
C++特殊类及单例模式
czh1592272237的博客
03-17 1157
在实际场景中，我们在编写类的过程中总会遇到一些特殊情况，比如设计一个类不能被拷贝/不能被继承/只能在堆上创建对象/只能在栈上创建对象/只能创建一个对象，基于这些场景，我们来谈谈这些特殊类该如何实现。
内部类和静态内部类的加载顺序
weixin_34174105的博客
06-02 257
先看代码： public class Test { public static void main(String[] args){ System.out.println("这是main方法"); System.out.println("---------------------分割线-------------------"); ...
java静态内部类加载顺序
热门推荐
0bug0warning的博客
12-13 1万+
静态内部类加载顺序 我们先来区分一下两个概念：类加载、加载。 类加载的过程包括加载，初始化，验证，解析，准备，初始化等五个过程。加载是类加载的一部分。 区分完这两个概念之后我们再来看下面的问题。 我们声明一个类，这个类有个内部静态类。还有主函数，当我们启动程序之后，运行java application......
静态内部类的类加载顺序
weixin_30906671的博客
03-15 192
一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。 那么加载一个类时，静态内部类是不是被看做“静态代码块”同时被加载了？下面我们做一个实验来看一下。 Java代码 publicclassOuter{ static{ System.out.println("loadouterclass..."...
JAVA静态内部类加载顺序
LMR的博客
05-23 8629
今天偶然机会碰到了JAVA的静态内部类加载实例，原本以为和外部类一样，但实验结果确出人意料，特此记录。希望大牛们能指出原因所在。 首先给上代码： public class LoadTest2 { public static class Inner{//静态内部类中的静态熟悉和静态代码块按照顺序加载 static { System.out.p...
单例设计模式中类加载顺序
大飞的博客
11-24 802
加载完类后，类的初始化就会发生，如果是对一个类的主动使用就会初始化对象,对类的被动使用不会对类进行初始化，比如final修饰的静态变量如果能在编译时就确定变量的取值,会被当做常量,作为对一个类的被动使用不会导致类的初始化。 以下情况类被初始化： 最常见的就是直接创建一个类的实例(new 一个对象)，有可能导致ClassNotFoundException。 调用一个类的静态方法，public st...
静态内部类实现单例_单例模式详解
weixin_39713814的博客
12-08 4677
概述单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，使用单例模式的类只有一个对象实例。单例应用场景Windows系统的任务管理器。Windows系统的回收站。操作系统的文件系统，一个操作系统只能有一个文件系统。数据库连接池的设计与实现。多线程的线程池设计与实现。Spring中创建的Bean实例默认都是单例。Java-Web中，一个Ser...
手撕单例模式——彻底搞懂饿汉式、懒汉式、静态内部类、枚举实现单例，以及通过反射和反序列化破坏单例
weixin_44340573的博客
10-02 757
单例模式的实现主要可以通过饿汉式、懒汉式（DCL）、静态内部类以及枚举实现。 其中饿汉式、懒汉式、静态内部类皆可以通过反射或序列化的方式破坏单例，而枚举可以有效的防止反射破坏单例。 注意：单例中的构造是私有的，只有私有构造器才能防止外部类轻易通过构造方法来创建实例，从而破坏单例。 饿汉式单例模式 所谓饿汉式就是直接在实例初始化时，便调用构造方法来创建单例。 public class Hungry { private Hungry(){ } private final static
单例模式的几种实现方式
水w的博客
11-18 1776
单例模式的几种实现方式
Java非静态内部类、静态内部类加载顺序
静笃塾
02-23 619
1基础概念 在OutClass类内部定义新的类InnerClass，该类即为内部类。内部类能够有效组织数据，具备代码隐藏机制；能够在外围类引用，并与外围类通信；能够简化代码，使代简洁易懂等。 2内部类创建 关于静态内部类、非静态内部类的加载顺序建议参考该文章，大致结论如下： ...
继承内部类静态方法加载顺序
Fanzongshen的博客
05-01 163
继承内部类静态方法加载顺序 /** * およそ神 * 继承内部类静态方法加载顺序 */ public class Test { public static void main(String[] args){ A ab = new B(); ab = new B(); } } class A{ static{ System.out.println("A中静态方法加载到方法区"); } public A(){
java的static关键字及类加载顺序
栋幺栋幺-的博客
11-17 1351
Java中static可以修饰类、变量、方法甚至可以构成静态块，让我们来了解下它们各自的使用以及加载顺序吧。 基本用法 static关键字修饰类 java里面用static修饰内部类，普通类是不允许声明为静态的，只有内部类才可以。 ```java public class StaticTest { //static关键字修饰内部类 public static class InnerClass{ InnerClass(){
java 类与非静态内部类、静态内部类、父类与子类 各代码块的加载顺序
xiangqianzou_liu的专栏
04-10 584
最近面试被问到外部类与静态内部类 各代码块的加载顺序，思考许久，最终回答的不理想，事后思考再三，还是对这块的加载顺序理解的不透彻，借此机会，重新认识并做了一些demo，俗话说“实践出真知”，以下是具体的总结和demo，奉上。 各代码块， 1、普通类与非静态内部类 各代码块的加载顺序的区别 ...
【Java】java中的类加载和对象创建
lmy
04-08 616
JAVA类的加载机制 Java类加载分为5个过程,分别为：加载，连接(验证，准备，解析)，初始化，使用，卸载。 加载 加载主要是将.class文件（也可以是zip包）通过二进制字节流读入到JVM中。 在加载阶段，JVM需要完成3件事： 1）通过classloader在classpath中获取XXX.class文件，将其以二进制流的形式读入内存。 2）将字节流所代表的静态存储结构转化为方法区的运行...
java单例静态变量加载顺序
zyysw的专栏
02-08 738
public class Person2 { private static Person2 singleton = new Person2(); static int name = 3; public static void main(String[] args) { Person2.get(); System.out.println(Person2.name); //Pers
Java类加载机制
weixin_44168355的博客
03-18 145
类加载过程 加载—验证—准备—解析—初始化
java加载顺序
weixin_42975911的博客
05-05 264
普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定–“先出现先执行”构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。如果类中包含多个静态代码块，那么将按照"先定义的代码先执行，后定义的代码后执行"。构造块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。
关于java内部类加载顺序的问题
astra_zhao的专栏
09-10 4909
前面是看到某个论坛讨论的内部类加载顺序的问题，链接如下：http://www.oschina.net/question/2273217_217864#tags_nav 今天看了单例模式，对内部类的加载顺序产生了疑问。所以来请教大家。 我们知道，java当中，类的加载顺序是：类静态块-类静态属性-类内部属性-类构造方法。 但是当有内部类的时候会怎样呢？我们先看一下代码。 ?
用静态内部类的方式实现单例模式为什么不会出现多线程并发问题
最新发布
03-13
<think>好的，我现在需要回答用户关于为什么静态内部类实现单例模式不会出现多线程并发问题。这个问题涉及到Java的内存模型、类加载机制以及单例模式的不同实现方式。用户可能已经了解过其他单例实现方式，比如双重检查锁或者饿汉式，现在想了解静态内部类的优势。 首先，我需要回顾静态内部类实现单例的具体结构。通常，这种实现方式会在单例类中定义一个私有的静态内部类，内部类中持有外部类的实例。外部类的静态方法（如getInstance()）会返回内部类中的实例。因为内部类是静态的，所以它的加载时机可能与外部类不同，这可能是关键点。 接下来，我需要理解类加载的机制。Java虚拟机在加载类的时候，会确保类的初始化阶段是线程安全的，由JVM内部的锁机制保证。也就是说，当多个线程同时尝试初始化一个类时，只有一个线程会执行初始化，其他线程会被阻塞直到初始化完成。因此，静态内部类在首次被访问时才会加载，此时JVM会保证其初始化的线程安全。 然后，我需要确认静态内部类中的静态变量（即单例实例）的初始化时机。由于内部类是静态的，只有在调用getInstance()方法时才会触发内部类的加载和初始化，这时才会创建单例实例。这个过程由JVM保证线程安全，因此不需要额外的同步措施。 还需要考虑用户可能的疑问，比如是否会出现指令重排序的问题。在双重检查锁定中，如果不使用volatile，可能会因为指令重排序导致问题。但在静态内部类的方式中，JVM在类初始化阶段已经处理了这些并发问题，因此无需担心。 用户可能也会想知道这种方式与其他实现（如枚举单例）的对比。不过当前问题集中在静态内部类，所以需要集中解释其原理。 最后，我需要用简洁明了的中文，分步骤解释静态内部类实现单例的线程安全机制，可能包括类加载机制、延迟加载、JVM的线程安全保证等。同时，可能提供一个代码示例来辅助说明。 在整理思路时，需要注意术语的准确性，比如“类初始化阶段的线程安全”、“延迟加载”、“静态内部类的加载时机”等，确保解释正确。同时要避免技术错误，比如错误地认为静态内部类本身是线程安全的，而实际上关键在于类加载过程由JVM保证线程安全。 总结，回答需要涵盖以下几点： 1. 静态内部类实现单例的结构。 2. 类加载机制如何保证线程安全。 3. 延迟加载的优势。 4. 与双重检查锁等方法的对比，说明为何不需要额外同步。 5. 可能的代码示例。</think>在 Java 中，通过**静态内部类**实现单例模式（通常称为 **Holder 模式**）可以天然避免多线程并发问题，其核心原理依赖于 **JVM 的类加载机制**和 **线程安全性保证**。以下是详细解释： --- ### 一、静态内部类实现单例的代码示例 ```java public class Singleton { // 私有构造方法，防止外部实例化 private Singleton() {} // 静态内部类 private static class Holder { // 在静态内部类中持有外部类的实例 private static final Singleton INSTANCE = new Singleton(); } // 对外提供获取实例的方法 public static Singleton getInstance() { return Holder.INSTANCE; // 触发静态内部类的加载和初始化 } } ``` --- ### 二、为什么不会出现多线程并发问题？ #### 1. **JVM 的类加载机制保证线程安全** - **关键点**：当 JVM 加载一个类时，会通过 **类初始化锁**（Class Initialization Lock）确保类的初始化（即 `<clinit>()` 方法）是线程安全的。 - **过程**： - 当多线程首次调用 `getInstance()` 时，会触发 `Holder` 类的加载和初始化。 - JVM 会为 `Holder` 类的初始化过程加锁，保证只有一个线程执行初始化代码（即 `INSTANCE = new Singleton()`），其他线程会被阻塞。 - 初始化完成后，后续线程直接获取已初始化的 `INSTANCE`。 #### 2. **延迟加载（Lazy Initialization）** - **特点**：`Holder` 类在首次调用 `getInstance()` 时才被加载，此时才会创建 `Singleton` 实例。 - **优势**：既实现了懒加载（避免类加载时立即初始化实例），又无需额外的同步开销。 #### 3. **静态变量的初始化保证** - 静态变量 `Holder.INSTANCE` 的赋值操作（`new Singleton()`）由 JVM 在类初始化阶段完成，且整个过程是原子性的。 - 无需担心指令重排序问题（JVM 保证类初始化的顺序性和可见性）。 --- ### 三、对比其他单例实现方式 | 实现方式 | 线程安全机制 | 延迟加载 | 复杂度 | |------------------------|--------------------------------|----------|------------------| | 静态内部类（Holder） | JVM 类加载锁 | ✔️ | 简单，无额外同步 | | 双重检查锁（DCL） | `synchronized` + `volatile` | ✔️ | 较复杂，需防重排序 | | 饿汉式 | 类加载时初始化（JVM 保证安全） | ❌ | 简单，但可能浪费资源 | | 枚举单例 | JVM 保证枚举实例唯一性 | ❌ | 简单且防反射破坏 | --- ### 四、常见疑问解答 #### 1. **为什么静态内部类不需要 `volatile`？** - 在双重检查锁中，`volatile` 用于禁止指令重排序，防止返回未完全初始化的对象。 - **静态内部类方式中**：`Holder.INSTANCE` 的初始化由 JVM 在类加载时完成，JVM 天然保证初始化过程的原子性和可见性，因此无需 `volatile`。 #### 2. **是否存在反射或序列化破坏单例的风险？** - 是的！静态内部类实现仍可能被反射或序列化破坏。若需完全防御，可： - 在构造方法中抛出异常防止反射调用。 - 实现 `readResolve()` 方法防止序列化破坏。 - 相比之下，**枚举单例**是《Effective Java》推荐的方式，天然防反射和序列化破坏。 --- ### 五、总结 - **静态内部类实现单例的线程安全性依赖 JVM 的类加载机制**，天然避免了多线程并发问题。 - **优势**：代码简洁、无锁、延迟加载、无指令重排序风险。 - **适用场景**：需要延迟加载且对代码简洁性要求较高的场景。若需防御反射或序列化攻击，可优先选择枚举单例。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值