JVM-JIT

最新推荐文章于 2022-04-12 13:06:58 发布

技术不值钱

最新推荐文章于 2022-04-12 13:06:58 发布

阅读量393

点赞数

分类专栏： java 文章标签： java jit jvm

本BLOG上原创文章未经本人许可，不得用于商业用途。转载请注明出处，否则保留追究法律责任的权利。

本文链接：https://blog.csdn.net/cow4j/article/details/119897828

版权

java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

JDK、JRE与JVM的关系

我们一直学习怎么使用Java，像我工作了好几年，也不知道这三者的关系，不知道也没关系，把自己不知道的让自己变成知道那就是进步，不要对自己有太高的期望，大家都是平常人。

下图很好的解释了这三者之间的关系：JDK包含了编译器等开发工具和JRE，而JRE包含了运行类库和JVM。那JVM又是个啥？

JVM和Java的关系

讲道理Java是一门语言，跟JVM关系不大，我们的Java代码经过编译后成为class文件，JVM加载的就是这些class文件，JVM并不是只能加载由Java编译的class文件，只要是符合JVM加载规范的class文件就能够被JVM加载，也就是说JVM加载class文件跟语言无关。未命名文件

字节码-机器码的区别

我们在学习《Java字节码》了解到字节码其实就是字节码文件，而这些字节码并不能被电脑执行，它是一种中间状态，需要通过JVM转译后才能被电脑执行。

机器码就是电脑CPU能够直接读取运行的机器指令，运行速度最快，但是非常难懂，也很难编写。所以通过字节码这种中间状态，然后再由JVM转译成机器码，这样开发人员就不用接触那些难懂又难写的机器码了。

JVM运行模式

JVM有两种运行模式：Client、Server。Client模式启动速度较快，Server模式启动较慢；

但是启动进入稳定期长期运行之后Server模式的程序运行速度比Client要快很多。

因为Server模式启动的JVM采用的是重量级的虚拟机，对程序采用了更多的优化；而Client模式启动的JVM采用的是轻量级的虚拟机。所以Server启动慢，但稳定后速度比Client远远要快。

JVM架构

未命名文件 (1)

从上图我们可以知道JVM是处在操作系统之上的，JVM与操作系统交互，然后再由操作系统与硬件交互。

那JVM内部是个啥样子？看下面这张JVM架构图，从图中我们可以知道，JVM大致可以分为三大块。

类加载系统
运行时数据区
执行引擎

JVM

JVM程序执行过程

编写Java代码
Java代码编译为class文件
ClassLoader加载class到运行时数据区
执行引擎对运行时数据区的数据进行解释或编译执行

为什么执行引擎要使用解释器与JIT编译器并存的架构？

当程序需要迅速启动和执行的时候，解释器可以首先发挥作用，省去编译的时间，立即执行。在程序运行一段时间后，编译器逐渐发挥作用，把越来越多的代码编译成本地代码(所谓本地代码，就是存在方法区中的内容)，这样可以获取更高的执行效率。
当程序运行环境中内存资源限制较大，可以使用解释器执行来节约内存，反之可以使用编译执行来提升效率。

编译时间开销

说JIT编译比解释快，其实说的“执行编译后的代码”比"解释器解释执行"要快，并不是说“编译”这个动作比“解释”这个动作快。JIT编译再怎么快，至少也比解释执行一次要慢一些，JIT需要先编译，然后再执行编译后的代码。对于只执行一次的代码而言，解释执行其实总是比JIT编译执行要快。

编译的空间开销

对一般的的Java方法而言，经过JIT编译后的代码的大小相对于字节码的大小，膨胀到10倍以上是很正常的。JIT编译器效率高，但空间的开销也会相对高一些，只有对执行频繁的代码才值得编译，如果把所有代码都编译则会增加代码所占空间，导致”代码爆炸“。

两个不同的即时编译器

HotSpot虚拟机中内置了两个即时编译器：Client Complier和Server Complier，简称为C1、C2编译器，分别用在客户端和服务端。

目前主流的HotSpot虚拟机中默认是采用解释器与其中一个编译器直接配合的方式工作。程序使用哪个编译器，取决于虚拟机运行的模式。-client或-server

用Client Complier获取更高的编译速度，用Server Complier来获取更始的编译质量。

对Client Compiler来说，它是一个简单快速的编译器，主要关注点在于局部优化，而放弃许多耗时较长的全局优化手段。

而Server Compiler则是专门面向服务器端的，并为服务端的性能配置特别调整过的编译器，是一个充分优化过的高级编译器。

JIT优化

公共子表达式消除

公共子表达式消除是一个普遍应用于各种编译器的经典优化技术。如果一个表达式E已经计算过了，并且从先前的计算到现在E中所有变量的值都没有发生变化，那么E的这次出现就成为了公共子表达式。对于这种表达式，没有必要花时间再对他进行计算，只需要直接用前面计算过的表达式结果代替E就可以了。例：

int d = (c*b)*12+a+(a+b*c);

如果这段代码交给Javac编译器则不会进行任何优化，那生成的代码如下所示：

iload_2 // b
imul // 计算b*c
bipush 12 // 推入12
imul // 计算(c*b)*12
iload_1 // a
iadd // 计算(c*b)*12+a
iload_1 // a
iload_2 // b
iload_3 // c
imul // 计算b*c
iadd // 计算a+b*c
iadd // 计算(c*b)*12+a+(a+b*c)
istore 4

当这段代码进入到虚拟机即时编译器后，他将进行如下优化：

编译器检测到“cb”与“bc”是一样的表达式，而且在计算期间b与c的值是不变的。

int d = E*12+a+(a+E);

编译器还可能进行另外一种优化：代数化简。表达式进行变换之后，再计算起来就可以节省一些时间了。

int d = E*13+a*2;

方法内联

在使用JIT进行即时编译时，将方法调用直接使用方法体中的代码进行替换，这就是方法内联，减少了方法调用过程中压栈与入栈的开销。同时为之后的一些优化手段提供条件。如果JVM监测到一些小方法被频繁的执行，它会把方法的调用替换成方法体本身。

private int add4(int x1, int x2, int x3, int x4) {
	return add2(x1, x2) + add2(x3, x4);
}

private int add2(int x1, int x2) {
	return x1 + x2;
}

运行一段时间后JVM会把add2方法去掉，并把你的代码翻译成：、

private int add4(int x1, int x2, int x3, int x4) {
	return x1 + x2 + x3 + x4;
}

逃逸分析

逃逸分析（Escape Analysis）是目前Java虚拟机中比较前沿的优化技术。这是一种可以有效减少Java程序同步负载和内存堆分配压力的跨函数全局数据流分析算法。通过逃逸分析，Java HotSpot编译器能够分析出一个新的对象的引用的使用范围从而决定是否要将这个对象分配到堆上。

逃逸分析的基本行为就是分析对象动态作用域：当一个对象在方法中被定义后，它可能被外部方法所引用，例如作为调用参数传递到其他地方，称为方法逃逸。

逃逸分析包括：

全局变量赋值逃逸
方法返回值逃逸
实例引用发生逃逸
线程逃逸：赋值给类变量或可以在其他线程中访问的实例变量

例如：

public class EscapeAnalysis {
    //全局变量
    public static Object object;
    public void globalVariableEscape(){//全局变量赋值逃逸
    	object = new Object();
    }

    public Object methodEscape(){ //方法返回值逃逸
    	return new Object();
    }

    public void instancePassEscape(){ //实例引用发生逃逸
    	this.speak(this);
    }

    public void speak(EscapeAnalysis escapeAnalysis){
    	System.out.println("Escape Hello");
    }

}

使用方法逃逸的案例进行分析：

public static StringBuffer craeteStringBuffer(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb;
}

StringBuffer sb是一个方法内部变量，上述代码中直接将sb返回，这样这个StringBuffer有可能被其他方法所改变，这样它的作用域就不只是在方法内部，虽然它是一个局部变量，称其逃逸到了方法外部。甚至还有可能被外部线程访问到，譬如赋值给类变量或可以在其他线程中访问的实例变量，称为线程逃逸。

上述代码如果想要StringBuffer sb不逃出方法，可以这样写：

public static String createStringBuffer(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();
}

使用逃逸分析，编译器可以对代码做如下优化：

1、同步省略。如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作可以不考虑同步。

2、将堆分配转化为栈分配。如果一个对象在子程序中被分配，要使用指向该对象的指针永远不会逃逸，对象可能是栈分配的候选，而不是堆分配。

3、分离对象或标量替换。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或全部）可以不存储在内存，而是存储在CPU寄存器中。

开启逃逸分析：

-XX:+DoEscapeAnalysis ：表示开启逃逸分析

-XX:-DoEscapeAnalysis ：表示关闭逃逸分析

从jdk1.7开始已经默认开启逃逸分析，如需关闭，需要指定-XX:-DoEscapeAnalysis

对象栈上分配

我们知道，在一般情况下，对象和数组元素的内存分配是在堆内存上进行的。但是随着JIT编译器的日渐成熟，很多优化使这种分配策略并不绝对。JIT编译器就可以在编译期间根据逃逸分析的结果，来决定是否可以将对象的内存分配从堆转化为栈。

public class EscapeAnalysisTest {

    public static void main(String[] args) {
        long a1 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            alloc();
        }
        // 查看执行时间
        long a2 = System.currentTimeMillis();
        System.out.println("cost " + (a2 - a1) + " ms");
        // 为了方便查看堆内存中对象个数，线程sleep
        try {
            Thread.sleep(100000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
    }

    private static void alloc() {
    	User user = new User();
    }

    static class User {
    }

}

循环在代码中创建100万个User对象。

我们在alloc方法中定义了User对象，但是并没有在方法外部引用他。也就是说，这个对象并不会逃逸到alloc外部。经过JIT的逃逸分析之后，就可以对其内存分配进行优化。

正常情况下，堆中共创建了100万个StackAllocTest$User实例。

开启了逃逸分析之后，在堆内存中只有8万多个StackAllocTest$User对象。也就是说在经过JIT优化之后，堆内存中分配的对象数量，从100万降到了8万。

所以，对象和数组不一定都会在堆内存分配空间，随着JIT编译器的发展，在编译期间，如果JIT经过逃逸分析，发现有些对象没有逃逸出方法，那么有可能堆内存分配会被优化成栈内存分配。但是这也并不是绝对的。

标题替换

标量（Scalar）是指一个无法再分解成更小的数据的数据。

在JIT阶段，如果经过逃逸分析，发现一个对象不会被外界访问的话，那么经过JIT优化，就会把这个对象拆解成若干个其中包含的若干个成员变量来代替。

//有一个类A

public class A{
    public int a=1;
    public int b=2
}

//方法getAB使用类A里面的a,b

private void getAB(){
    A x = new A();
    x.a;
    x.b;
}

//JVM在编译的时候会直接编译成

private void getAB(){
    a = 1;
    b = 2;
}

//这就是标量替换

同步锁消除

同样基于逃逸分析，当加锁的变量不会发生逃逸，是线程私有的完全没有必要加锁。在JIT编译时期就可以将同步锁去掉，以减少加锁与解锁造成的资源开销。

public class TestLockEliminate {

    public static String getString(String s1, String s2) {
        StringBuffer sb = new StringBuffer();
        sb.append(s1);
        sb.append(s2);
        return sb.toString();
    }

    public static void main(String[] args) {
        long tsStart = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            getString("TestLockEliminate ", "Suffix");
        }
        System.out.println("一共耗费：" + (System.currentTimeMillis() - tsStart) + " ms");
    }

}

getString()方法中的StringBuffer数以函数内部的局部变量，作用于方法内部，不可能逃逸出该方法，因此他就不可能被多个线程同时访问，也就没有资源的竞争，但是StringBuffer的append操作却需要执行同步操作，代码如下：

@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

总结

这里我们介绍了JVM的基本知识，以及对JIT编译器有了一定的了解。我们最需要熟悉的还是类加载系统以及运行时数据区，今天就先大致介绍了JVM的知识，后面篇幅将介绍JVM的类加载系统。

技术不值钱

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JVM-JIT

JDK、JRE与JVM的关系我们一直学习怎么使用Java，像我工作了好几年，也不知道这三者的关系，不知道也没关系，把自己不知道的让自己变成知道那就是进步，不要对自己有太高的期望，大家都是平常人。下图很好的解释了这三者之间的关系：JDK包含了编译器等开发工具和JRE，而JRE包含了运行类库和JVM。那JVM又是个啥？JVM和Java的关系讲道理Java是一门语言，跟JVM关系不大，我们的Java代码经过编译后成为class文件，JVM加载的就是这些class文件，JVM并不是只能加载由Java编译的
复制链接

扫一扫