java 虚拟机 代码块_从虚拟机的角度理解静态代码块和构造代码块

最新推荐文章于 2022-03-28 11:24:21 发布
最新推荐文章于 2022-03-28 11:24:21 发布
阅读量159 收藏
点赞数
文章标签： java 虚拟机 代码块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_32698563/article/details/114813157
版权

所谓静态代码块，是指用static关键字修饰的代码块，特点是代码块会在类的构造代码块、构造函数之前运行， 且只会执行一次。而构造代码块，则就是单纯的由花括号构成的代码块，特点是代码块会在类的构造函数之前运行， 且每次实例化对象都会被调用。本篇blog从虚拟机的角度描述静态代码块和构造代码块，加深理解。

首先，我们要知道，当你将.java文件编译成.class文件时，如果有静态代码块的话， 他会在.class文件中插入一段称为的函数代替静态代码块。如果有构造代码块，他会在各个构造函数中插入一段称为的函数代替构造代码块

其次，我们要理解类的生命周期(如下图)，函数的调用发生在初始化阶段，而初始化阶段仅有一次，所以函数仅会调用一次，这就是为什么 静态代码块仅会在“使用类”的时候被调用一次，其他情况均不会被调用。

e52461bdaec20201b20772999672c2e1.png

咱们使用javap反汇编看看。

public classStudent {static{

System.out.println("第一个构造代码块");

}static{

System.out.println("第二个构造代码块");

}

{

System.out.println("第一个构造代码块");

}

{

System.out.println("第二个构造代码块");

}publicStudent() {

System.out.println("默认构造函数");

}public Student(String name,intage) {

System.out.println("自定义构造函数");this.name =name;this.age =age;

}private String name = "Clive";private static int age = 17;private final static String COUNTRY = "CN";private final String SCHOOL = "JXAU";

}/*E:\eclipseWork\Test\bin\test>javap -c Student

警告: 二进制文件Student包含test.Student

Compiled from "Student.java"

public class test.Student {

static {};

Code:

0: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

3: ldc #25 // String 第一个构造代码块

5: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

8: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

11: ldc #33 // String 第二个构造代码块

13: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

16: bipush 17

18: putstatic #35 // Field age:I

21: return

public test.Student();

Code:

0: aload_0

1: invokespecial #40 // Method java/lang/Object."":()V

4: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

7: ldc #25 // String 第一个构造代码块

9: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

12: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

15: ldc #33 // String 第二个构造代码块

17: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

20: aload_0

21: ldc #42 // String Clive

23: putfield #44 // Field name:Ljava/lang/String;

26: aload_0

27: ldc #14 // String JXAU

29: putfield #46 // Field SCHOOL:Ljava/lang/String;

32: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

35: ldc #48 // String 默认构造函数

37: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

40: return

public test.Student(java.lang.String, int);

Code:

0: aload_0

1: invokespecial #40 // Method java/lang/Object."":()V

4: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

7: ldc #25 // String 第一个构造代码块

9: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

12: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

15: ldc #33 // String 第二个构造代码块

17: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

20: aload_0

21: ldc #42 // String Clive

23: putfield #44 // Field name:Ljava/lang/String;

26: aload_0

27: ldc #14 // String JXAU

29: putfield #46 // Field SCHOOL:Ljava/lang/String;

32: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

35: ldc #53 // String 自定义构造函数

37: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

40: aload_0

41: aload_1

42: putfield #44 // Field name:Ljava/lang/String;

45: iload_2

46: putstatic #35 // Field age:I

49: return

}*/

咦？说好的函数呢？这是因为函数不能被java调用，它只能作为类加载过程的一部分由JVM直接调用，具体见文末引用。JVM对函数做了“美化处理”， 反汇编的代码中static {};就是指静态代码块。从函数中，我们可以得到一些信息。

多个静态代码块最终会融合成一个函数供JVM调用

源码中有两个静态代码块，而反汇编得出的代码仅有一个

静态数据域的赋值操作在函数中完成

数据域age是静态数据域(private static int age = 17;)，对应函数中偏移量为18的指定。

18: putstatic #28 // Field age:I

从构造函数中，我们可以得到与构造代码块相关的一些信息

final static数据域的赋值操作不在函数中完成

数据域COUNTRY用了不仅用了static关键字修饰，还用了final修饰，但是反汇编代码中并没有相关的赋值指令， 因为当一个数据域用final修饰时，其赋值操作在准备阶段就已经完成了，数据域SCHOOL也是如此。

每当构造函数运行时，函数都会被调用

从反汇编代码中可以看到，默认构造函数和自定义构造函数中都插入了一段调用函数的字节码指令， invokespecial #33 // Method java/lang/Object."":()V 这也就是为什么构造代码块有这个特性：每次实例化对象时静态代码块都会被执行，且在构造函数之前执行

多个构造代码块也被融合成了一个函数

源码中有两个构造代码块，而构造函数中仅调用了一次函数，可见虚拟机将构造代码快融合了

普通数据域的赋值操作在构造函数中完成

数据域name是普通的数据域(private String name = "Clive";)。赋值操作在默认构造函数中对应的是 偏移量为21的字节码指令，在自定义构造函数中，对应的字节码偏移量也为21。

静态代码块与的关系，构造代码块与的关系

根据上面的反汇编代码，我们得知，把函数简单的当做静态代码块是错误的一个观点，因为函数中还包含了 对静态数据域的赋值操作，所以，函数与静态代码块的关系应该是包含关系。构造代码块与的关系也是如此，不再赘述。

继承关系中的

当父类中也有静态代码块时，子类的静态代码块中并没有显示或者隐式调用父类静态代码块的指令，但虚拟机会保证在子类的函数运行之前，父类的已经运行完成。

并非所有类都会产生函数

如果类中没有静态代码块，也没有静态数据域的赋值操作，也就不会产出函数

public classStudent {

{

System.out.println("第一个构造代码块");

}

{

System.out.println("第二个构造代码块");

}publicStudent() {

System.out.println("默认构造函数");

}public Student(String name,intage) {

System.out.println("自定义构造函数");this.name =name;

}private String name = "Clive";private final static String COUNTRY = "CN";private final String SCHOOL = "JXAU";

}/*E:\eclipseWork\Test\bin\test>javap -c Student

警告: 二进制文件Student包含test.Student

Compiled from "Student.java"

public class test.Student {

public test.Student();

Code:

0: aload_0

1: invokespecial #17 // Method java/lang/Object."":()V

4: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

7: ldc #25 // String 第一个构造代码块

9: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

12: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

15: ldc #33 // String 第二个构造代码块

17: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

20: aload_0

21: ldc #35 // String Clive

23: putfield #37 // Field name:Ljava/lang/String;

26: aload_0

27: ldc #12 // String JXAU

29: putfield #39 // Field SCHOOL:Ljava/lang/String;

32: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

35: ldc #41 // String 默认构造函数

37: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

40: return

public test.Student(java.lang.String, int);

Code:

0: aload_0

1: invokespecial #17 // Method java/lang/Object."":()V

4: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

7: ldc #25 // String 第一个构造代码块

9: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

12: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

15: ldc #33 // String 第二个构造代码块

17: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

20: aload_0

21: ldc #35 // String Clive

23: putfield #37 // Field name:Ljava/lang/String;

26: aload_0

27: ldc #12 // String JXAU

29: putfield #39 // Field SCHOOL:Ljava/lang/String;

32: getstatic #19 // Field java/lang/System.out:Ljava/io/PrintStream;

35: ldc #48 // String 自定义构造函数

37: invokevirtual #27 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

40: aload_0

41: aload_1

42: putfield #37 // Field name:Ljava/lang/String;

45: return

}*/

把Student中静态代码块和静态数据域删掉，最终生成的反汇编代码中并没有函数

接口也会产生函数

接口中是不可以写静态代码块的(The interface XXX cannot define an initializer)，但其数据域都默认是静态的， 所以也会产生函数。另外，只有真正使用了这个接口，其函数才会运行。也就是说，两个接口A、B，A是B的父接口， 当使用B接口时，A接口的函数并不会用运行，只有真正使用了A接口，其函数才会运行，比如使用接口中的数据域。 另外，我不想骗各位，书上大意是如此，但是，我用javap生成的反汇编代码发现，并没有生成函数，而是生成了一个默认构造函数,里面有对数据域的赋值操作，我想可能是JDK版本不同吧 :)

public classSpeak {int COUNT = 2;

}/*E:\eclipseWork\Test\bin\test>javap -c Speak

警告: 二进制文件Speak包含test.Speak

Compiled from "Speak.java"

public class test.Speak {

int COUNT;

public test.Speak();

Code:

0: aload_0

1: invokespecial #10 // Method java/lang/Object."":()V

4: aload_0

5: iconst_2

6: putfield #12 // Field COUNT:I

9: return

}*/

函数的线程安全性

虚拟机内部，为确保其线程安全，当多线程视图初始化同一个类时，仅一条线程允许进入函数，其他线程必须等待。当函数 执行完成时，其他线程发现函数已经执行完毕，也就不会在执行函数了。这种互斥的同步操作使用锁完成的，有锁就 有可能导致死锁，如下。

packagetest;importjava.sql.SQLException;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;public classTest {public static void main(String[] args) throwsClassNotFoundException, SQLException {//模仿多线程情况下初始化类// ExecutorService executor =Executors.newCachedThreadPool();

executor.execute(new Task("test.A"));

executor.execute(new Task("test.B"));

executor.shutdown();

System.out.println("over");

}private static class Task implementsRunnable {privateString className;publicTask(String className) {this.className =className;

}public voidrun() {try{

Class.forName(className);

}catch(ClassNotFoundException e) {

e.printStackTrace();

}

}

}

}

packagetest;public classA {static{

System.out.println("enter static block of A");try{

Thread.sleep(5000);

Class.forName("test.B"); //初始化B

} catch(ClassNotFoundException e) {

e.printStackTrace();

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println("out static block of A");

}

}

packagetest;public classB {static{

System.out.println("enter static block of B");try{

Thread.sleep(5000);

Class.forName("test.A"); //初始化A

} catch(ClassNotFoundException e) {

e.printStackTrace();

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println("out static block of B");

}

}

上述代码模拟了在多线程环境下初始化类而造成的死锁现象。当一个线程进入类A的函数时， 根据代码，其又要初始化类B，而类B的函数已经由另一个线程占据，且要初始化类A。这样双方都抱着自己的资源不放，又去请求别的资源，自然会造成死锁。

总结

函数包含了静态代码块中的代码，在类的初始化阶段运行，且仅会运行一次。包含了构造代码块中的代码，在实例化对象的时候运行，会在构造函数之前运行

引用

1.《深入理解Java虚拟机》

2.《实战Java虚拟机》

3.论坛：http://hllvm.group.iteye.com/group/topic/35224

小马宋
关注
深入理解Java虚拟机（JVM）中静态块、静态属性、构造块、构造方法的执行顺序（通俗易懂）
weixin_44361445的博客
04-27 319
在Java程序中，类的初始化过程中涉及到许多重要的概念，其中包括静态块、静态属性、构造块和构造方法。本论文将深入探讨Java虚拟机（JVM）中静态块、静态属性、构造块、构造方法的执行顺序。综上所述，静态块和静态属性在类加载时执行，而构造块和构造方法在对象创建时执行。静态块和静态属性只会执行一次，而构造块和构造方法在每次创建对象时都会执行。标题：深入理解Java虚拟机（JVM）中静态块、静态属性、构造块、构造方法的执行顺序。静态块是类中的一个静态代码块，用于在类被加载时执行一次。
java static块 执行时机_深入java虚拟机之类的静态代码块执行时机
weixin_39860636的博客
02-24 77
publicclassTest{publicstaticvoidmain(String[]args)throwsClassNotFoundException{//System.out.println(Class.forName("java.lang.String").getClassLoader());//System.out.println(Class.forName("...
深入java虚拟机之类的静态代码块执行时机
weixin_34242509的博客
09-30 106
为什么80%的码农都做不了架构师？>>> ...
java static 块作用_JAVA静态代码块的作用
weixin_29000417的博客
02-16 191
一 般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情 况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的. 静态方法在类加载的时候 就已经加载 可以用类名直接调用比如main方法就必须是静态的 这是程序入口两者的区别就是:静态代码块是自动执行的;静态方法是被调用的时候才执行的.区别很简单...
JVM笔记 - 05接口的初始化规则
Gump_roader的博客
01-17 400
目录1、接口基本特性的回顾1.1接口的成员变量的默认修饰符1.2接口不允许有静态代码块2、接口的初始化规则 说明：笔记内容来源于《北京圣思园教育 - 张龙老师 - 深入理解JVM》视频课程。如有侵权，请联系删除。 1、接口基本特性的回顾 1.1接口的成员变量的默认修饰符 接口的成员变量，修饰符默认是"public static final" 比如，下面代码中，变量a、b的修饰符都是"public static final" package com.test; public class MyTest5 {
java面试题中的判断题
CSDN1782747395的博客
11-21 9325
1、Java语言有三种技术平台，分别是JavaSE、JavaME、JavaEE（T） 2、Java是一门高级计算机语言。（T） 3、Java语言具体跨平台的特性（T） 4、JDK工具中自带了一个JRE工具（T） 5、JDK安装的时候不可以修改安装目录（F） 6、JDK的安装目录中，只包含bin和lib两个目录。（F） 7、javac命令可以运行Demo.class文件（F） 8、在任意命令行窗口中...
Java静态代码块作用及执行顺序解析
08-19
在继承关系中，静态代码块的执行顺序是：父类静态代码块 -> 子类静态代码块 -> 父类非静态代码块 -> 父类构造方法 -> 子类非静态代码块 -> 子类构造方法。 静态代码块和静态方法的区别在于：静态代码块是自动执行的...
Java的静态代码块、非静态代码块、构造函数
01-12
Java编程语言中，静态代码块、非静态代码块和构造函数是面向对象设计的重要组成部分，它们在类的初始化和对象创建过程中起到关键作用。本文将深入探讨这些概念，以及它们在实际开发中的应用。 首先，我们来理解静态...
Java中的static静态代码块的使用详解
09-05
Java中的静态代码块是类级别的代码，它在类被加载到JVM（Java虚拟机）时执行，且只执行一次。这些代码块主要用于初始化类级别的变量，即静态变量。与静态方法不同，静态代码块是自动执行的，而静态方法需要通过类名...
java代码-日常练习33，代码块### 静态代码块 static{代码内容;} 随着类的加载就执行一次 构造器代码块 {代码内容;} 每创建对象就执行一次 局部代码块 {代码内容;} 方法执行一次执行一次
07-15
静态代码块由`static`关键字标识，它是在类被加载到Java虚拟机（JVM）时执行的，且只会执行一次。静态代码块通常用来初始化类级别的变量，因为它在任何对象实例化之前就已经运行。这样的设计使得程序员可以在不创建...
【渝粤教育】21秋期末考试Java程序设计基础10232k2
渝粤题库
12-23 836
科目编号：3717 座位号 2018-2019学年度第二学期期末考试 天然气管道长输技术 试题 2018年 7 月 一、填空题（本大题共5空，每空5分，共计25分） 1．管材的选择应考虑钢材的__________________、、以及管道使用环境等方面的要求。 2．输气管道末段应该既能储气，又能。 3．在输气管道设计中考虑效率系数E是为了_____________________________________________________。 二、判断题
浅谈JVM虚拟机运行时数据区运行原理
Alex_thomas的博客
03-28 1452
前言： Java程序运行的过程中，JVM会将其所管理的内存划分成若干个区域，统称为是运行时数据区。其中，一些线程间共享的区域，随着JVM的启动而创建，JVM的退出而销毁；另一些线程私有的区域，则随着线程的开始而创建，线程的结束而销毁。如图所示，运行时数据区由以下几个区域所组成：程序计数器、Java虚拟机栈、本地方法栈、方法区、堆。 ...
从底层原理（JVM）上，深刻理解构造代码块为何总先（早）于构造方法执行
小伍的程序之路
03-31 1267
构造代码块 构造方法
Java中的构造代码块与静态代码块的特点
黄飞的博客专栏
08-02 2018
1、静态代码块的执行： public class StaticTest {     static     {         System.out.println("hello,world!");         System.exit(0);     }     public static void main(String[] args)     {         Sys
java虚拟机（JVM）运行时数据内存区域分配及其原理说明
朱宏的博客
06-16 499
java跨平台 java是跨平台运行的编程语言，因为java有JVM虚拟机作为java语言的一个解释平台解释成字节码文件，计算机都可识别和运行。java文件后缀名一般是.java，在运行的时候会被编译成.class文件。编译过程如图所示： JVM运行时数据区域 JVM在运行java文件时会自动分配不同的内存来存储不同的数据。各自为营，提供不同的数据服务，同时也有自己生成，执行，销毁的生命周期。java提供多线程机制，线程共享则是多线程可以共同维护一份数据的区域，线程隔离则是线程之间互不相关的.
从虚拟机的角度理解静态代码块和构造代码块
weixin_30667301的博客
04-23 67
所谓静态代码块，是指用static关键字修饰的代码块，特点是代码块会在类的构造代码块、构造函数之前运行， 且只会执行一次。而构造代码块，则就是单纯的由花括号构成的代码块，特点是代码块会在类的构造函数之前运行， 且每次实例化对象都会被调用。本篇blog从虚拟机的角度描述静态代码块和构造代码块，加深理解。 首先，我们要知道，当你将.java文件编译成.class文件时，如果有静态代码块的话...
构造代码块、静态构造代码块的区别以及构造方法的执行顺序
qq_51148472的博客
11-10 609
1.什么是代码块 代码块就是在java直接写在方法或是定义在语句中。 {} 就称为代码块 例如：if(){} 条件语句代码块 for(){}循环语句代码块 2.构造代码块 1.构造代码块是直接写在类中的代码块 piblic class Demo{ //创建构造代码块 { System.out.println("这是构造代码块"); } } 静态构造代码块 2.静态构造代码块 静态构造代码块时使用static关键字声明的代码 static 修饰的
java虚拟机工作原理图_JVM 底层原理总结
weixin_39900180的博客
02-17 346
JAVA虚拟机：一、如上图所示，JAVA虚拟机运行时主要由以下三个部分构成：A. 本地库接口负责把描述类的数据从Class文件加载到内存，并对数据进行校验、装换解析、以及初始化，最终形成可以被虚拟机直接使用的Java类型。在Java语言中，类型的加载、连接和初始化过程都是在程序运行期间完成的。B. 运行时数据区1)方法区。2)堆。3)虚拟机栈。4)本地方法栈。5)程序计数器。C. 执行引擎输入的是...
Java中构造代码块和静态代码块
m0_46672151的博客
12-04 1709
介绍构造代码块和静态代码块的格式和特性。末尾给出了一个静态代码块在数据库连接池应用的简单介绍。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值