文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

JMH性能测试,试试你代码的性能如何

2024-12-02 11:01

关注

最近在研究一些基础组件实现的时候遇到一个问题,关于不同技术的运行性能比对该如何去实现。

什么是性能比对呢?

举个简单的栗子🌰 来说:假设我们需要验证String,StringBuffer,StringBuilder三者在使用的时候,希望能够通过一些测试来比对它们的性能开销。下边我罗列出最简单的测试思路:

for循环比对

这种测试思路的特点:简单直接 

  1. public class TestStringAppendDemo {  
  2.     public static void testStringAdd() {  
  3.         long begin = System.currentTimeMillis();  
  4.         String item = new String();  
  5.         for (int i = 0; i < 100000; i++) {  
  6.             itemitem = item + "-";  
  7.         }  
  8.         long end = System.currentTimeMillis();  
  9.         System.out.println("StringBuffer 耗时:" + (end - begin) + "ms");  
  10.     }  
  11.     public static void testStringBufferAdd() {  
  12.         long begin = System.currentTimeMillis();  
  13.         StringBuffer item = new StringBuffer();  
  14.         for (int i = 0; i < 100000; i++) {  
  15.             itemitem = item.append("-");  
  16.         }  
  17.         long end = System.currentTimeMillis();  
  18.         System.out.println("StringBuffer 耗时:" + (end - begin) + "ms");  
  19.     }  
  20.     public static void testStringBuilderAdd() {  
  21.         long begin = System.currentTimeMillis();  
  22.         StringBuilder item = new StringBuilder();  
  23.         for (int i = 0; i < 100000; i++) {  
  24.             itemitem = item.append("-");  
  25.         }  
  26.         long end = System.currentTimeMillis();  
  27.         System.out.println("StringBuilder 耗时:" + (end - begin) + "ms");  
  28.     }  
  29.     public static void main(String[] args) {  
  30.             testStringAdd();  
  31.             testStringBufferAdd();  
  32.             testStringBuilderAdd();  
  33.     }  

不知道你在平时工作中是否经常会这么做,虽然说通过简单的for循环执行来看,我们确实能够较好地给出谁强谁弱的这种结论,但是比对的结果并不精准。因为Java程序的运行时有可能会越跑越快的!

代码越跑越快

看到这里你可能会有些疑惑,Java程序不是在启动之前都编译成了统一的字节码么,难道在字节码翻译为机器代码的过程中还有什么不为人知的优化处理手段?

下边我们来观察这么一段测试程序: 

  1. public static void testStringAdd() {  
  2.         long begin = System.currentTimeMillis();  
  3.         String item = new String();  
  4.         for (int i = 0; i < 100000; i++) {  
  5.             itemitem = item + "-";  
  6.         }  
  7.         long end = System.currentTimeMillis();  
  8.         System.out.println("String 耗时:" + (end - begin) + "ms");  
  9.     }  
  10.     //循环20次执行同一个方法  
  11.     public static void main(String[] args) {  
  12.         for(int i=0;i<20;i++){  
  13.             testStringAdd();  
  14.         }  
  15.     } 

执行的程序耗时打印在了控制台上:

20次的重复调用之后,发现首次和最后一次调用几乎存在5倍的差异。看来代码运行越跑越快是存在的了,但是为什么会有这种现象发生呢?

这里我们需要了解一项叫做JIT的技术。

JIT技术

在介绍JIT技术之前,需要先进行些相关知识的补充铺垫。

解释型语言

解释型语言,是在运行的时候才将程序翻译成 机器语言 。解释型语言的程序不需要在运行前提前做编译工作,在运行程序的时候才翻译,解释器负责在每个语句执行的时候解释程序代码。这样解释型语言每执行一次就要“翻译”一次,效率比较低。代表语言:PHP。

编译型语言

在程序执行之前,提前就将程序编译成机器代码,这样后续机器在运行的时候就不需要额外去做翻译的工作,效率会相对较高。语言代表:C,C++。

而我们本文重点研究的是Java语言,我个人认为这是一门既具备解释特点又具备编译特点的高级语言。

JVM是Java一次编译,跨平台执行的基础。当Java被编译为字节码形式的.class文件之后,他可以在任意的JVM上运行。

PS: 这里说的编译,主要是指前端编译器。

前端编译器

将.java文件编译为JVM可执行的.class字节码文件,即javac,主要职责包括:词法、语法分析,填充符号表,语义分析,字节码生成。输出为字节码文件,也可以理解为是中间表达形式(称为IR:Intermediate Representation)。这时候的编译结果就是我们常见的xxx.class文件。

后端编译器

在程序运行期间将字节码转变成机器码,通过前端编译器和后端编译器的组合使用,通常就是被我们称之为混合模式,如 HotSpot 虚拟机自带的解释器还有 JIT(Just In Time Compiler)编译器(分 Client 端和 Server 端),其中JIT还会将中间表达形式进行一些优化。

所以一份xxx.java的文件实际在执行过程中会按照如下流程执行,首先经过前端解释器转换为.class格式的字节码,再通过后端编译器将其解释为机器能够识别的机器代码。最后再由机器去执行计算。

真的就这么简单吗?

还记得我在上边贴出的那段测试代码吗,首次执行和最后执行的性能差异如此巨大,其实是在后端编译器处理的过程中加入优化的手段。

在编译时,主要是将java源代码文件编译为统一的字节码,但是编译成的字节码并不能直接运行,而是需要通过JVM读取运行。JVM中的后端解释器就是将.class文件一行一行翻译之后再运行,翻译就是转换成当前机器可以运行的机器码,它不会一次性把整个文件都翻译过来,而是翻译一句,执行一句,再翻译,再执行,所以解释器的程序运行起来会比较慢,每次都要解释之后再执行。所以有些时候,我们想是否可以把解释之后的内容缓存起来,这样不就可以直接运行了?但是,如果每段代码都要缓存起来,例如仅仅执行一次的代码也缓存起来,这样太浪费内存了。所以,引入一个新的运行时编译器,JIT来解决这些问题,加速热点代码的执行。

引入JIT技术之后,代码的执行过程是怎样的?

在引入了JIT技术之后,一份Java程序的代码执行流程就会变成了下边这种类型。首先通过前端编译器转变为字节码文件,然后再判断对应的字节码文件是否有被提前处理好存放在code cache中。如果有则可以直接执行对应的机器代码,如果没有则需要进行判断是否有必要进行JIT技术优化(判断逻辑的细节后边会讲),如果有必要优化,则会将优化后的机器码也存放到code cache中,否则则是会一边执行一边翻译为机器代码。

怎样的代码才会被识别为热点代码呢?

在JVM中会设置一个阈值,当某段代码块在一定时间内被执行的次数超过了这个阈值,则会被存放进code cache中。

如何验证:

建立一个测试用的代码Demo,然后设置JVM参数:

-XX:CompileThreshold=500 -XX:+PrintCompilation 

  1. public class TestCountDemo {  
  2.     public static void test() {  
  3.         int a = 0 
  4.     }  
  5.    public static void main(String[] args) throws InterruptedException {  
  6.         for (int i = 0; i < 600; i++) {  
  7.             test();  
  8.         }  
  9.         TimeUnit.SECONDS.sleep(1);  
  10.     }  

接下来专心观察启动程序之后的编译信息记录:

截图解释:

第一列693表示系统启动到编译完成时的毫秒数。

第二列43表示编译任务的内部ID,一般是一个自增的值。

第三列为空,描述代码状态的5个属性。

第四列3表示编译级别,0表示没有编译而是使用解释器,1,2,3表示使用C1编译器(client),4表示使用C2编译器(server),级别越高编译生成的机器码质量越好,编译耗时也越长。

最后一列表示了方法的全限定名和方法的字节码长度。

从实验来看,当for循环的次数一旦超过了预期设置的阈值,则会提前使用后端编译器将代码缓存到code cache中。

即时编译极大地提高了Java程序的运行速度,而且跟静态编译相比,即时编译器可以选择性地编译热点代码,省去了很多编译时间,也节省很多的空间。目前,即时编译器已经非常成熟了,在性能层面甚至可以和编译型语言相比。不过在这个领域,大家依然在不断探索如何结合不同的编译方式,使用更加智能的手段来提升程序的运行速度。

还记得我在文章开头所提出的几个问题吗~~既然我们了解了Jvm底层具备了这些优化的技能,那么如何才能更加准确高效地去检测一段程序的性能呢?

基于JMH来实践代码基准测试

JMH是Java Microbenchmark Harness的简称,一个针对Java做基准测试的工具,是由开发JVM的那群人开发的。想准确的对一段代码做基准性能测试并不容易,因为JVM层面在编译期、运行时对代码做很多优化,但是当代码块处于整个系统中运行时这些优化并不一定会生效,从而产生错误的基准测试结果,而这个问题就是JMH要解决的。

关于如何使用JMH在网上有很多的讲解案例,这些入门的资料大家可以自行去搜索。本文主要讲解在使用JMH测试的时候需要注意到的一些细节点:

常用的基本注解以及其具体含义

一般我们会将测试所使用的注解都标注在测试类的头部,常用到的测试注解有以下几种: 

  1.   
  2. @BenchmarkMode(Mode.Throughput) 
  3.   
  4. @Warmup(iterations = 3 
  5.   
  6. @Measurement(iterations = 10time = 5timeUnit = TimeUnit.SECONDS)  
  7.   
  8. @Threads(8)  
  9.   
  10. @Fork(2)  
  11.   
  12. @OutputTimeUnit(TimeUnit.MILLISECONDS) 

如果不喜欢使用注解的方式也可以通过在启动入口中通过硬编码的形式设置: 

  1. public static void main(String[] args) throws RunnerException {  
  2.         //配置进行2轮热数 测试2轮 1个线程  
  3.         //预热的原因 是JVM在代码执行多次会有优化  
  4.         Options options = new OptionsBuilder().warmupIterations(2).measurementBatchSize(2)  
  5.                 .forks(1).build();  
  6.         new Runner(options).run();  
  7.     } 

如果要对某项方法进行JMH测试的话,通常会对该方法的头部加入@Benchmark注解。例如下边这段: 

  1. @Benchmark  
  2.     public String testJdkProxy() throws Throwable {  
  3.         String content = dataService.sendData("test");  
  4.         return content;  
  5.     } 

JMH的一些坑

所有方法都应该要有返回值

例如这么一段测试案例: 

  1. package org.idea.qiyu.framework.jmh.demo;  
  2. import org.openjdk.jmh.annotations.*;  
  3. import org.openjdk.jmh.runner.Runner;  
  4. import org.openjdk.jmh.runner.RunnerException;  
  5. import org.openjdk.jmh.runner.options.Options;  
  6. import org.openjdk.jmh.runner.options.OptionsBuilder;  
  7. import java.util.concurrent.TimeUnit;  
  8. import static org.openjdk.jmh.annotations.Mode.AverageTime;  
  9. import static org.openjdk.jmh.annotations.Mode.Throughput;  
  10.   
  11. @BenchmarkMode(Throughput)  
  12. @Fork(2)  
  13. @Warmup(iterations = 4 
  14. @Threads(4)  
  15. @OutputTimeUnit(TimeUnit.MILLISECONDS)  
  16. public class JMHHelloWord { 
  17.     @Benchmark  
  18.     public void baseMethod() {  
  19.     }  
  20.     @Benchmark  
  21.     public void measureWrong() {  
  22.         String item = "" 
  23.         itemitem = item + "s";  
  24.     }  
  25.     @Benchmark  
  26.     public String measureRight() {  
  27.         String item = "" 
  28.         itemitem = item + "s";  
  29.         return item;  
  30.     }  
  31.     public static void main(String[] args) throws RunnerException {  
  32.         Options options = new OptionsBuilder().  
  33.                 include(JMHHelloWord.class.getName()).  
  34.                 build();  
  35.         new Runner(options).run();  
  36.     }  

其实baseMethod和measureWrong两个方法从代码功能角度看来,并没有什么区别,因为调用它们两者对于调用方本身并没有造成什么影响,而且measureWrong函数中还存在着无用代码块,所以JMH会对内部的代码进行“死码消除”的处理。

通过测试会发现,其实baseMethod和measureWrong的吞吐性结果差别不大。反而再比对measureWrong和measureRight两个方法,后者只是加入了一个return关键字,JMH就能很好地去测算它的整体性能。

关于什么是“死码消除”,我在这里贴出一段维基百科上的介绍,感兴趣的读者可以自行前往阅读:

https://zh.wikipedia.org/wiki/死碼刪除

不要在Benchmark内部加入循环的代码

关于这一点我们可以通过一段案例来进行测试,代码如下: 

  1. package org.idea.qiyu.framework.jmh.demo;  
  2. import org.openjdk.jmh.annotations.*;  
  3. import org.openjdk.jmh.runner.Runner;  
  4. import org.openjdk.jmh.runner.RunnerException;  
  5. import org.openjdk.jmh.runner.options.Options;  
  6. import org.openjdk.jmh.runner.options.OptionsBuilder;  
  7. import java.util.concurrent.TimeUnit;  
  8.   
  9. @BenchmarkMode(Mode.AverageTime)  
  10. @Fork(1)  
  11. @Threads(4)  
  12. @Warmup(iterations = 1 
  13. @OutputTimeUnit(TimeUnit.MILLISECONDS)  
  14. public class ForLoopDemo {  
  15.     public int reps(int count) {  
  16.         int sum = 0
  17.         for (int i = 0; i < count; i++) {  
  18.             sumsum = sum + count;  
  19.         }  
  20.         return sum;  
  21.     }  
  22.     @Benchmark  
  23.     @OperationsPerInvocation(1)  
  24.     public int test_1() {  
  25.         return reps(1);  
  26.     }  
  27.     @Benchmark  
  28.     @OperationsPerInvocation(10)  
  29.     public int test_2() {  
  30.         return reps(10);  
  31.     }  
  32.     @Benchmark  
  33.     @OperationsPerInvocation(100)  
  34.     public int test_3() {  
  35.         return reps(100);  
  36.     }  
  37.     @Benchmark  
  38.     @OperationsPerInvocation(1000)  
  39.     public int test_4() {  
  40.         return reps(1000);  
  41.     }  
  42.     @Benchmark  
  43.     @OperationsPerInvocation(10000)  
  44.     public int test_5() {  
  45.         return reps(10000);  
  46.     }  
  47.     @Benchmark 
  48.     @OperationsPerInvocation(100000)  
  49.     public int test_6() {  
  50.         return reps(100000);  
  51.     }  
  52.     public static void main(String[] args) throws RunnerException {  
  53.         Options options = new OptionsBuilder()  
  54.                 .include(ForLoopDemo.class.getName())  
  55.                 .build();  
  56.         new Runner(options).run();  
  57.     }  

测试出来的结果显示:

循环越多,反而得分越低,这一结果反而越来越不可信。

关于为什么在Benchmark中跑循环代码会出现这类不可信的情况,我在网上搜了一下技术文章,大致归纳为以下:

感兴趣的朋友可以自行去深入了解,这里我就不做过多介绍了。

通过这个实验可以发现,以后进行Benchmark的性能测试过程中,尽量能不跑循环就不要跑循环,如果真的要跑循环,可以看下官方的这个用例:

https://github.com/lexburner/JMH-samples/blob/master/src/main/java/org/openjdk/jmh/samples/JMHSample_34_SafeLooping.java

Fork注解中的进程数一定要大于0

这个是我通过实验发现的,如果设置为小于0的参数会发现跑出来的效果和预期的大大相反,具体原因还不太清楚。

测试结果报告的参数解释

最后是关于如何阅读JMH的测试报告,这里的这份报告是上边讲解的代码案例中的测试结果。由于报告的内容量比较大,所以这里只挑报告的结果来进行讲解: 

  1. Benchmark                   Mode  Cnt         Score        Error   Units  
  2. JMHHelloWord.baseMethod    thrpt   10  14343234.962 ± 585752.043  ops/ms  
  3. JMHHelloWord.measureRight  thrpt   10    260749.234 ±   5324.982  ops/ms  
  4. JMHHelloWord.measureWrong  thrpt   10    524449.863 ±   8330.106  ops/ms 

从报告的左往右开始介绍起:

关于Error的解释,在stackoverflow中也有解释:

https://codereview.stackexchange.com/questions/90886/jmh-benchmark-metrics-evaluation

如果你希望报告不是输出在控制台,而是可以汇总到一份文档中,可以通过启动指令去设置,例如: 

  1. public static void main(String[] args) throws RunnerException {  
  2.         Options options = new OptionsBuilder()  
  3.                 .include(StringBuilderBenchmark.class.getSimpleName())  
  4.                 .output("/Users/linhao/IdeaProjects/qiyu-framework-gitee/qiyu-framework/qiyu-framework-jmh/log/test.log")  
  5.                 .build();  
  6.         new Runner(options).run();  
  7.     }  

 

来源:Java知音内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯