Java代码有很多运行方式。
 
 

在开发工具中运行
双击jar文件运行
在命令行中运行
在网页中运行
当然，上述运行方式都离不开JRE， 也就是Java运行时环境。
 
JRE仅包含Java程序的必须组件，包括Java虚拟机以及Java核心类库等。
 
而我们Java程序员经常接触到的JDK(Java开发工具包)同样包含了JRE, 并且还附带了一系列开发、诊断工具。
 
然而，运行C++程序则无需额外的运行时环境，C++编译器往往把C++代码编译成CPU能够理解的机器码。
 
那么，既然C++的运行方式如此成熟，我们为什么要在JVM里运行Java代码呢？
 
为什么Java要在虚拟机里运行？
 
Java作为一门高级程序语言，它的语法复杂，抽象程度也很高。因此在硬件上运行Java代码并不现实，所以运行Java程序之前，我们需要对其进行一番转换。
 
当前进行转换的主要思路是：设计一个面向Java语言特性的虚拟机，并通过编译器将Java程序转换层该虚拟机所能识别的指令序列(Java字节码)。之所以这么取名，是因为Java字节码指令的操作码被固定成一个字节。
 
Java虚拟机可以由硬件实现
 
https://en.wikipedia.org/wiki/Java_processor
 
当然，更多时候还是在各个现有平台(Windows_x64,Linux_aarch64)上提供软件实现。这么做的目的在于，一旦一个程序被编译成Java字节码，那么它变可以在不同平台上的虚拟机实现里运行。这也就是平时我们所说的Java的跨平台特性。
 
虚拟机的另外一个好处是它带来了一个托管环境(Managed Runtime)。这个托管环境能够代替我们处理一些代码中冗长而且容易出错的部分。其中最广为人知的当属自动内存管理与垃圾回收，这部分内容甚至催生了一波垃圾回收调优的业务。
 
除此之外，托管环境还提供了诸如数组越界，动态类型、安全权限等等的动态监测，使我们免于书写这些无关业务逻辑的代码。
 
Java虚拟机具体是怎么运行Java字节码的？
 
以标准JDK中的HotSpot虚拟机为例，从虚拟机和底层硬件两个角度，剖析该问题。
 
从虚拟机的角度来看，执行Java代码首先需要将它编译而成的class文件加载到Java虚拟机中。加载后的Java类会被存放于方法区(Method Area)中。实际运行时，虚拟机会执行方法区内的代码。
 
如果你熟悉X86的话，你会发现这和段式存储管理中的代码段类似。而且，Java虚拟机同样也会在内存中划分出堆和栈来存储运行时的数据。不同的是，Java虚拟机会将栈细分为面向Java方法的Java方法栈，面向本地方法（用C++写的native方法）的本地方法栈，以及存放各个线程执行位置的PC寄存器。
 
 
 
 
在运行过程中，每当调用进入一个Java方法，Java虚拟机会在当前线程的Java方法栈中生成一个栈帧，用以存放局部变量以及字节码的操作数。这个栈帧的大小是提前计算好的，而且Java虚拟机不要求栈帧在内存空间里连续分布。
 
当退出当前执行的方法时，不管是正常返回还是异常返回，Java虚拟机均会弹出当前线程的栈帧，并将之舍弃。
 
在HotSpot里面，上述翻译过程有两种形式
 
解释执行，即逐条将字节码翻译成机器码并执行。
即时编译(Just-In-Time compilation, JIT), 即将一个方法中包含的所有字节码编译成机器码后再执行。
 
前者的优势是无需等待编译，而后者的优势在于实际的运行速度更快。
 
HotSpot默认采用混合模式，综合了解释执行和即时编译两者的优点。
 
它会首先解释字节码。然后将其中反复执行的热点代码，以方法为单位即时编译。
 
Java虚拟机的运行效率究竟是怎么样的？
 
HotSpot采用了多种技术来提升峰值性能，上文提到的即时编译技术便是其中最重要的技术之一。
 
即时编译建立在程序符合二八定律的假设上。
 
二八定律：20%的代码占用了程序执行过程中80%的资源。
 
对于占据大部分的不常用的代码，我们无需耗费时间将其编译成机器码，而是采用解释执行的方式。
 
另一方面，对于仅占据小部分的热点代码，我们则可以将其编译成机器码，打到理想的运行速度。
 
理论上讲，即时编译后的Java程序的执行效率，是可以超过C++程序的。这是因为与静态编译相比，即时编译拥有程序的运行时信息，并且能够根据这个信息做出相应的优化。(实际上,编译时会插入一些有关jvm的代码)
 
举个例子，我们知道虚方法是用来实现面向对象语言多态性的。对于一个虚方法调用，尽管它有很多个目标方法，但在实际运行过程中他可能只调用了其中的一个，这个信息便可以被即时编译器所利用，来规避虚方法调用的开销从而达到比静态编译的C++程序更高的性能。
 
为了满足不同用户场景的需要，HotSpot内置了多个即时编译器：C1、C2和Graal。 Graal是Java 10正式引入的实验性即时编译器。
 
之所以引入多个即时编译器，是为了在编译时间和生成代码的执行效率之间做取舍。 C1又叫做Client编译器，面向的是对启动性能有要求的客户端GUI程序，采用的优化手段相对简单，因此编译时间较短。C2又叫做Server编译器，面向的是对峰值性能有要求的服务端程序，采用的优化手段相对复杂，因此编译时间较长，但同时生成代码的执行效率较高。
 
从Java 7开始，HotSpot默认采用分层编译的方式：热点方法首先被C1编译，而后热点方法中的热点会进一步被C2编译。
 
为了不干扰应用的正常运行，HotSpot的即时编译是放在额外的编译线程中进行的。HotSpot会根据CPU的数量设置编译线程的数目，并且按1:2的比例配置给C1及C2编译器。
 
在计算资源充足的情况下，字节码的解释执行和即时编译可同时进行。编译完成后的机器码后再下次调用时启用，以替换原本的解释执行。
 
我们来完成老师布置的作业:了解Java语言和Java虚拟机看待boolean类型的方式是否不同。
 
首先，撰写代码Foo.java
 

 

   

    

   
   

    

     public 
     class Foo {
    
   

   

    

   
   

    
	
     public static void main(String[] args){
    
   

   

    

   
   

    
		
     boolean flag = 
     true;
    
   

   

    

   
   

    
		
     if(flag)
    
   

   

    

   
   

    

     			System.out.println(
     "Hello, Java!!");
    
   

   

    

   
   

    
		
     if(flag == 
     true)
    
   

   

    

   
   

    

     			System.out.println(
     "Hello, JVM!!!");
    
   

   

    

   
   

    

     	}
    
   

   

    

   
   

    

     }
    
   
 
 

 

   

    

   
   

    

     javac Foo.java
    
   

   

    

   
   

    

     java Foo
    
   
 
 
显然，它的执行结果是：
 
Hello, Java!!
 Hello, JVM!!!
 
我们使用asmtools.jar对其进行反汇编(此命令JDK7无法运行, 需要升级到JDK8)
 
下载地址:https://download.csdn.net/download/ti_an_di/10555815
 
java -cp ./asmtools.jar org.openjdk.asmtools.jdis.Main Foo.class > Foo.jasm.1
 
 
我们得到它的反汇编代码(在Foo.jasm.1 中)
 

 

   

    

   
   

    
 
    
   

   

    

   
   

    

     super 
     public 
     class Foo
    
   

   

    

   
   

    
	
     version 52:0
    
   

   

    

   
   

    

     {
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     public Method 
     "<init>":
     "()V"
    
   

   

    

   
   

    

     	stack 
     1 locals 
     1
    
   

   

    

   
   

    

     {
    
   

   

    

   
   

    

     		aload_0;
    
   

   

    

   
   

    

     		invokespecial	Method java/lang/Object.
     "<init>":
     "()V";
    
   

   

    

   
   

    
		
     return;
    
   

   

    

   
   

    

     }
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     public 
     static Method main:
     "([Ljava/lang/String;)V"
    
   

   

    

   
   

    

     	stack 
     2 locals 
     2
    
   

   

    

   
   

    

     {
    
   

   

    

   
   

    

     		iconst_1;
     //看这里
    
   

   

    

   
   

    

     		istore_1;
    
   

   

    

   
   

    

     		iload_1;
    
   

   

    

   
   

    

     		ifeq	L14;
    
   

   

    

   
   

    

     		getstatic	Field java/lang/System.out:
     "Ljava/io/PrintStream;";
    
   

   

    

   
   

    

     		ldc	String 
     "Hello, Java!!";
    
   

   

    

   
   

    

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

   

    

   
   

    

     	L14:	stack_frame_type append;
    
   

   

    

   
   

    

     		locals_map 
     int;
    
   

   

    

   
   

    

     		iload_1;
    
   

   

    

   
   

    

     		iconst_1;
    
   

   

    

   
   

    

     		if_icmpne	L27;
    
   

   

    

   
   

    

     		getstatic	Field java/lang/System.out:
     "Ljava/io/PrintStream;";
    
   

   

    

   
   

    

     		ldc	String 
     "Hello, JVM!!!";
    
   

   

    

   
   

    

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

   

    

   
   

    

     	L27:	stack_frame_type same;
    
   

   

    

   
   

    
		
     return;
    
   

   

    

   
   

    

     }
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     } 
     // end Class Foo
    
   
 
 
在运行指令
 
awk 'NR==1,/iconst_1/{sub(/iconst_1/, "iconst_2")} 1' Foo.jasm.1 > Foo.jasm
 
 
其作用是将Foo.jasm.1文件中第一个iconst_1 替换为iconst_2, 输出到文件Foo.jasm中
 

 

   

    

   
   

    
 
    
   

   

    

   
   

    

     super 
     public 
     class Foo
    
   

   

    

   
   

    

     	version 
     52:
     0
    
   

   

    

   
   

    

     {
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     public Method 
     "<init>":
     "()V"
    
   

   

    

   
   

    

     	stack 
     1 locals 
     1
    
   

   

    

   
   

    

     {
    
   

   

    

   
   

    

     		aload_0;
    
   

   

    

   
   

    

     		invokespecial	Method java/lang/Object.
     "<init>":
     "()V";
    
   

   

    

   
   

    
		
     return;
    
   

   

    

   
   

    

     }
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     public static Method main:
     "([Ljava/lang/String;)V"
    
   

   

    

   
   

    

     	stack 
     2 locals 
     2
    
   

   

    

   
   

    

     {
    
   

   

    

   
   

    

     		iconst_2; 
     //看这里
    
   

   

    

   
   

    

     		istore_1;
    
   

   

    

   
   

    

     		iload_1;
    
   

   

    

   
   

    

     		ifeq	L14;
    
   

   

    

   
   

    

     		getstatic	Field java/lang/System.
     out:
     "Ljava/io/PrintStream;";
    
   

   

    

   
   

    

     		ldc	String 
     "Hello, Java!!";
    
   

   

    

   
   

    

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

   

    

   
   

    

     	L14:	stack_frame_type append;
    
   

   

    

   
   

    

     		locals_map int;
    
   

   

    

   
   

    

     		iload_1;
    
   

   

    

   
   

    

     		iconst_1;
    
   

   

    

   
   

    

     		if_icmpne	L27;
    
   

   

    

   
   

    

     		getstatic	Field java/lang/System.
     out:
     "Ljava/io/PrintStream;";
    
   

   

    

   
   

    

     		ldc	String 
     "Hello, JVM!!!";
    
   

   

    

   
   

    

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

   

    

   
   

    

     	L27:	stack_frame_type same;
    
   

   

    

   
   

    
		
     return;
    
   

   

    

   
   

    

     }
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     } 
     // end Class Foo
    
   
 
 
我们现在将flag的值由1改为了2， 将修改后的代码汇编到Foo.class文件中
 
java -cp ./asmtools.jar org.openjdk.asmtools.jasm.Main Foo.jasm
 
 
再次运行Foo类
 

 

   

    

   
   

    

     java Foo
    
   

   

    

   
   

    

     Hello, Java!!
    
   
 
 
可见JVM将true视为1， 不等于修改为2的flag，使用if_icmpne指令判断他们不相等，直接跳到L27执行，所以Hello, JVM!!!不会输出。而第一次判断是使用ifeq判断flag的值是否为0，所以Hello，Java!!会输出。
 
此文从极客时间专栏《深入理解Java虚拟机》搬运而来，撰写此文的目的：
 
 
对自己的学习总结归纳
 
 
此篇文章对想深入理解Java虚拟机的人来说是非常不错的文章，希望大家支持一下郑老师。
 

JSRUN 功能大更新，为大家放送
  网页在线编辑器 
  Node.js代码在线运行 
  PHP代码在线运行 
  Java代码在线运行 
  C语言代码在线运行 
  Shell代码在线运行 
  C++代码在线运行 
  Ruby代码在线运行 
  Lua代码在线运行 
  Python代码在线运行 
  Go语言代码在线运行 
  Groovy代码在线运行 

 
 
《深入拆解Java虚拟机》学习笔记
 专栏地址：http://gk.link/a/1018S
 个人博客：http://laijianfeng.org
 
 
Java 和 C++ 在运行方式上的区别？
 
Java 代码有很多种不同的运行方式，比如在开发工具中运行、双击执行 jar 文件运行、在命令行中运行，甚至可以在网页中运行。
 
 
 
Java 的运行离不开 JRE（Java 运行时环境）， JRE 仅包含运行 Java 程序的必需组件，包括 Java 虚拟机以及 Java 核心类库等。当然我们程序员更经常接触到的是 JDK（Java 开发工具包），包含了JRE，并且还附带了一系列开发、诊断工具。
 
 
运行 C++ 代码则无需额外的运行时，往往把代码直接编译成 CPU 所能理解的机器码即可。
 
为什么 Java 要在虚拟机里运行？
 
Java 作为一门高级程序语言，它的语法非常复杂，抽象程度也很高。因此，直接在硬件上运行这种复杂的程序并不现实。
 
所以可以在 Java 代码与机器码之间加一层虚拟机，先将 Java 代码转换成 Java 字节码，最后才转换成机器码，降低复杂度。
 
Java Hello World 字节码格式
 
 
Java 虚拟机的好处
 
 
通过为各个平台（Linux、Windows、Mac os等）提供Java虚拟机的软件实现，在各个平台上都可以将Java代码转换成字节码来运行Java（可移植性），达到 “一次编写、到处运行” 的目的
 
 
Java虚拟机为我们带来了一个托管环境（Managed Runtime），可以替我们处理一些冗长而且容易出错的代码，最重要的譬如自动内存管理与垃圾回收，同时还提供诸如数组越界、动态类型、安全权限等的动态检测，让我们可以专心的写业务代码
 
 
Java 虚拟机具体是怎样运行 Java 字节码的？
 
首先从虚拟机的角度来看：
 
首先将 Java 代码编译成的 class 文件
将 class 文件加载到 Java 虚拟机中（载入Java内存），加载后的 Java 类会被存放于方法区（Method Area）中
运行时，虚拟机执行方法区内的代码
 
 
Java 虚拟机会将栈细分为面向 Java 方法的 Java 方法栈，面向本地方法（用 C++ 写的 native 方法）的本地方法栈，以及存放各个线程执行位置的** PC 寄存器**。
 
 
 
本地方法，用关键字 native 修饰，基于JNI（Java Native Interface，Java本地接口），它允许 Java 代码和其他语言写的代码进行交互
 
 
在运行过程中，每当调用进入一个 Java 方法，Java 虚拟机会在当前线程的 Java 方法栈中生成
 一个栈帧，用以存放局部变量以及字节码的操作数。（栈帧是提前计算好且不需连续分布）
 
当退出当前执行的方法时，不管是正常返回还是异常返回，Java 虚拟机均会弹出当前线程的当前栈帧，并将之舍弃。
 
Java 虚拟机将字节码翻译成机器码有两种形式：
 
解释执行：即逐条将字节码翻译成机器码并执行；
即时编译（Just-In-Time compilation，JIT），即将一个方法中包含的所有字节码编译成机器码后再执行。
 
 
解释执行的好处是无须等待编译，即时编译的好处是实际执行速度更快。
 
HotSpot 默认采用混合模式，综合了解释执行和即时编译两者的优点，它会先解释执行字节码，然后将其中反复执行的热点代码，以方法为单位进行即时编译。
 
关于即时编译
 
即时编译主要是为了提高 Java 虚拟机的启动性能以及峰值性能，它建立在程序符合二八定律的假设上，也就是百分之二十的代码占据了百分之八十的计算资源。
 
对于百分之八十（大部分）不常用的代码，我们无需耗费时间将其编译成机器码，而是采取解释执行的方式运行；对于百分之二十（小部分）的热点代码，我们则可以将其编译成机器码，以达到理想的运行速度。
 
为了满足不同用户场景的需要（在编译时间和生成代码的执行效率之间进行取舍），HotSpot 内置了多个即时编译器：C1、C2 和 Graal
 
C1，又叫 Client 编译器，面向的是对启动性能有要求的客户端 GUI 程序，采用的优化手段相对简单，编译时间较短。
C2，又叫 Server 编译器，面向的是对峰值性能有要求的服务器端程序，采用的优化手段相对复杂，编译时间较长，但同时生成代码的执行效率较高。
Graal 是Java 10 正式引入的实验性即时编译器
 
从 Java 7 开始，HotSpot 默认采用分层编译的方式：热点方法首先会被 C1 编译，而后热点方法中的热点会进一步被 C2 编译。
 
小作业：观察两个条件判断语句的运行结果
 
通过观察两个条件判断语句的运行结果，来思考 Java 语言和 Java 虚拟机看待 boolean 类型的方式是否不同？
 
点击下载asmtools，并在命令行中运行下述指令
 
 
 
注：ASM 是一个 Java 字节码操控框架
 
 
$ echo '
public class Foo {
 public static void main(String[] args) {
  boolean flag = true;
  if (flag) System.out.println("Hello, Java!");
  if (flag == true) System.out.println("Hello, JVM!");
 }
}' > Foo.java
$ javac Foo.java
$ java Foo
$ java -cp /path/to/asmtools.jar org.openjdk.asmtools.jdis.Main Foo.class > Foo.jasm.1
$ awk 'NR==1,/iconst_1/{sub(/iconst_1/, "iconst_2")} 1' Foo.jasm.1 > Foo.jasm
$ java -cp /path/to/asmtools.jar org.openjdk.asmtools.jasm.Main Foo.jasm
$ java Foo
 
 
结果分析：（来自评论区）
 
 
 
jvm 把 boolean 当做 int 来处理，flag = iconst_1 = true
 awk 把 stackframe 中的 flag 改为 iconst_2
 if（flag）比较时ifeq指令做是否为零判断，常数2仍为true，打印输出
 if（true == flag）比较时if_cmpne做整数比较，iconst_1是否等于flag，比较失败，不再打
 印输出
 
 
Hotspot 中的热点代码探测技术
 
怎样区分热点代码呢？主要有下面两种方法：
 
基于采样的热点探测
基于计数器的热点探测
 
计数器方法又可细分为方法调用计数器和汇编计数器
 
 
 
HotSpot的热点代码探测技术
 
 
 
方法调用计数器 统计一个相对的执行频率，即一段时间内方法被调用的次数，当超过一定的时间限度，如果方法的调用次数仍然不足以让它提交给即时编译器，那这个方法的调用计数器就会被减少一半，这个过程称为方法调用计数器热度的衰减，而这段时间就称为方法统计的半衰周期，进行热度衰减的动作在虚拟机进行垃圾收集时顺便进行了。一般采用的都是基于计数器的热点探测，基于计数器的热点探测又有两个计数器，方法调用计数器，回边计数器，他们在C1和C2又有不同的阈值
 
 
汇编计数器统计一个方法体重循环体代码执行的次数，在字节码中遇到控制流向后跳转的指令称为汇编，显然，建立汇编计数器的目的就是为了触发OSR编译。没有计数热度衰减的过程，因此这个计数器统计的就是该方法执行循环的绝对次数，当计数器溢出的时候它还会把方法计数器的值也调整到溢出的状态，这样下去在再次进入该方法的时候就会执行标准编译过程。
 
 
 
扫码购买可加入专栏进行学习，一起成长
 

※ 用一个代码执行指定python程序
 
本文主要介绍一个简单的小知识，即利用一个代码去执行所有你所写好的代码程序。
 
直接开工！
 
import os
os.system("python 执行的代码路径")
 
只需要这两行代码就可以直接运行指定路径里的代码，下面简单举个例子操作运行一下。
 
 如图所示，假如我们想要一次性将编号1-8的8个代码通过一个代码执行，我们就可以通过参照上面那两行代码来完成。具体写法也很简单。如下图：
 
import os
os.system("python ./1训练交通.py")
os.system("python ./2训练教育.py")
os.system("python ./3训练科技.py")
os.system("python ./4训练体育.py")
os.system("python ./5训练经济.py")
os.system("python ./6训练艺术.py")
os.system("python ./7训练电影.py")
os.system("python ./8训练政治.py")
 
然后我们将这个代码和想要运行的代码放到一个文件夹中，即放在了相同路径下，如果执行的程序在不同路径下，只需要复制路径，替换掉上图中 py 文件的路径即可。 运行这个代码后，被指定的代码程序就会依次执行。
 如果想要将执行的结果同时保存到同一文档中，只需要在在路径后添加保存文档的路径即可。如下图：
 
import os
os.system("python ./交通1.py >>AAAAAAAAAA.txt")
os.system("python ./教育2.py >>AAAAAAAAAA.txt")
os.system("python ./科技3.py >>AAAAAAAAAA.txt")
os.system("python ./体育4.py >>AAAAAAAAAA.txt")
os.system("python ./经济5.py >>AAAAAAAAAA.txt")
os.system("python ./艺术6.py >>AAAAAAAAAA.txt")
os.system("python ./电影7.py >>AAAAAAAAAA.txt")
os.system("python ./政治8.py >>AAAAAAAAAA.txt")
 
搞定收工。
 
“☺☺☺ 若本篇文章对你有一丝丝帮助，请帮顶、评论点赞，谢谢。☺☺☺”
 
↓↓↓↓