傻傻”的JAVA编译器

故事是从一个问题开始的:为什么 Java 中 2 * (i * i) 比 2 * i * i更快?

猛地一看,我还以为有人在钓鱼,这俩玩意不应该是一模一样吗?第二反应是计算结果溢出了int值所以导致了这个差异,于是我掏出JMH这个利器准备开始一轮验证,为了避免干扰,构造了不同的测试用例集用于纵向和横向的比较。

@BenchmarkMode(Mode.AverageTime)                  // 测试方法平均执行时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)             // 输出结果的时间粒度为纳秒
@State(Scope.Thread)                              // 运行相同测试的所有线程将共享实例。可以用来测试状态对象的多线程性能(或者仅标记该范围的基准)。
@Warmup(iterations = 2, time = 1)                 // 执行5遍预热
@Measurement(iterations = 10, time = 1)           // 执行5遍测试
@Fork(1)
public class CompileBenchMarkDemo {@Param({"1477", "1000000000"})private int size;public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(CompileBenchMarkDemo.class.getSimpleName()).build();new Runner(opt).run();}@Benchmarkpublic int twoSquare() {int n = 0;for (int i = 0; i < size; i++) {n += 2 * (i * i);}return n;}@Benchmarkpublic int twoNoSquare() {int n = 0;for (int i = 0; i < size; i++) {n += 2 * i * i;}return n;}@Benchmarkpublic long twoSquareWithLong() {long n = 0;for (long i = 0; i < size; i++) {n += 2 * (i * i);}return n;}@Benchmarkpublic long twoNoSquareWithLong() {long n = 0;for (long i = 0; i < size; i++) {n += 2 * i * i;}return n;}}

可以看到为了避免int溢出的干扰我使用了long来做累加,还有将i的范围限制到1477保证int不溢出

openjdk version "1.8.0_382-internal"
OpenJDK Runtime Environment (build 1.8.0_382-internal-b05)
OpenJDK 64-Bit Server VM (build 25.382-b05, mixed mode)

在上述jdk版本下最终结果如下:

Benchmark                                     (size)  Mode  Cnt          Score          Error  Units
CompileBenchMarkDemo.twoSquare            1000000000  avgt   10  461970038.267 ± 13350368.542  ns/op
CompileBenchMarkDemo.twoNoSquare          1000000000  avgt   10  744365243.050 ± 37840802.126  ns/op
CompileBenchMarkDemo.twoSquareWithLong    1000000000  avgt   10  799079820.550 ± 12835540.327  ns/op
CompileBenchMarkDemo.twoNoSquareWithLong  1000000000  avgt   10  906846479.450 ± 41247832.592  ns/op
CompileBenchMarkDemo.twoSquare                  1477  avgt   10        717.674 ±       19.992  ns/op
CompileBenchMarkDemo.twoNoSquare                1477  avgt   10       1144.875 ±      100.242  ns/op
CompileBenchMarkDemo.twoSquareWithLong          1477  avgt   10        979.668 ±       58.368  ns/op
CompileBenchMarkDemo.twoNoSquareWithLong        1477  avgt   10       1208.143 ±       97.710  ns/op

结果出乎我的意料,没想到在溢出和不溢出的情况下2 * ( i * i ) 始终优于 2 * i * i

于是我打算从字节码一探究竟

 0 iconst_01 istore_12 iconst_03 istore_24 iload_25 ldc #11 <1000000000>7 if_icmpge 24 (+17)
10 iload_1
11 iconst_2
12 iload_2
13 iload_2
14 imul
15 imul
16 iadd
17 istore_1
18 iinc 2 by 1
21 goto 4 (-17)
24 iload_1
25 ireturn
0 iconst_0
1 istore_1
2 iconst_0
3 istore_2
4 iload_2
5 ldc #11 <1000000000>
7 if_icmpge 24 (+17)
10 iload_1
11 iconst_2
12 iload_2
13 imul
14 iload_2
15 imul
16 iadd
17 istore_1
18 iinc 2 by 1
21 goto 4 (-17)
24 iload_1
25 ireturn

可以看到字节码上除了iload_2imul的顺序不一致所有字节码都是相同的,那么这个顺序为什么会有如此大的区别呢?字节码不行那就更下一层,让我们看看汇编代码的区别。

JIT 倾向于非常积极地展开小循环,我们观察到该2 * (i * i)案例展开了 16 倍:

030   B2: # B2 B3 <- B1 B2  Loop: B2-B2 inner main of N18 Freq: 1e+006
030     addl    R11, RBP    # int
033     movl    RBP, R13    # spill
036     addl    RBP, #14    # int
039     imull   RBP, RBP    # int
03c     movl    R9, R13 # spill
03f     addl    R9, #13 # int
043     imull   R9, R9  # int
047     sall    RBP, #1
049     sall    R9, #1
04c     movl    R8, R13 # spill
04f     addl    R8, #15 # int
053     movl    R10, R8 # spill
056     movdl   XMM1, R8    # spill
05b     imull   R10, R8 # int
05f     movl    R8, R13 # spill
062     addl    R8, #12 # int
066     imull   R8, R8  # int
06a     sall    R10, #1
06d     movl    [rsp + #32], R10    # spill
072     sall    R8, #1
075     movl    RBX, R13    # spill
078     addl    RBX, #11    # int
07b     imull   RBX, RBX    # int
07e     movl    RCX, R13    # spill
081     addl    RCX, #10    # int
084     imull   RCX, RCX    # int
087     sall    RBX, #1
089     sall    RCX, #1
08b     movl    RDX, R13    # spill
08e     addl    RDX, #8 # int
091     imull   RDX, RDX    # int
094     movl    RDI, R13    # spill
097     addl    RDI, #7 # int
09a     imull   RDI, RDI    # int
09d     sall    RDX, #1
09f     sall    RDI, #1
0a1     movl    RAX, R13    # spill
0a4     addl    RAX, #6 # int
0a7     imull   RAX, RAX    # int
0aa     movl    RSI, R13    # spill
0ad     addl    RSI, #4 # int
0b0     imull   RSI, RSI    # int
0b3     sall    RAX, #1
0b5     sall    RSI, #1
0b7     movl    R10, R13    # spill
0ba     addl    R10, #2 # int
0be     imull   R10, R10    # int
0c2     movl    R14, R13    # spill
0c5     incl    R14 # int
0c8     imull   R14, R14    # int
0cc     sall    R10, #1
0cf     sall    R14, #1
0d2     addl    R14, R11    # int
0d5     addl    R14, R10    # int
0d8     movl    R10, R13    # spill
0db     addl    R10, #3 # int
0df     imull   R10, R10    # int
0e3     movl    R11, R13    # spill
0e6     addl    R11, #5 # int
0ea     imull   R11, R11    # int
0ee     sall    R10, #1
0f1     addl    R10, R14    # int
0f4     addl    R10, RSI    # int
0f7     sall    R11, #1
0fa     addl    R11, R10    # int
0fd     addl    R11, RAX    # int
100     addl    R11, RDI    # int
103     addl    R11, RDX    # int
106     movl    R10, R13    # spill
109     addl    R10, #9 # int
10d     imull   R10, R10    # int
111     sall    R10, #1
114     addl    R10, R11    # int
117     addl    R10, RCX    # int
11a     addl    R10, RBX    # int
11d     addl    R10, R8 # int
120     addl    R9, R10 # int
123     addl    RBP, R9 # int
126     addl    RBP, [RSP + #32 (32-bit)]   # int
12a     addl    R13, #16    # int
12e     movl    R11, R13    # spill
131     imull   R11, R13    # int
135     sall    R11, #1
138     cmpl    R13, #999999985
13f     jl     B2   # loop end  P=1.000000 C=6554623.000000

我们看到有 1 个寄存器”溢出”到堆栈上。

对于2 * i * i版本:

05a   B3: # B2 B4 <- B1 B2  Loop: B3-B2 inner main of N18 Freq: 1e+006
05a     addl    RBX, R11    # int
05d     movl    [rsp + #32], RBX    # spill
061     movl    R11, R8 # spill
064     addl    R11, #15    # int
068     movl    [rsp + #36], R11    # spill
06d     movl    R11, R8 # spill
070     addl    R11, #14    # int
074     movl    R10, R9 # spill
077     addl    R10, #16    # int
07b     movdl   XMM2, R10   # spill
080     movl    RCX, R9 # spill
083     addl    RCX, #14    # int
086     movdl   XMM1, RCX   # spill
08a     movl    R10, R9 # spill
08d     addl    R10, #12    # int
091     movdl   XMM4, R10   # spill
096     movl    RCX, R9 # spill
099     addl    RCX, #10    # int
09c     movdl   XMM6, RCX   # spill
0a0     movl    RBX, R9 # spill
0a3     addl    RBX, #8 # int
0a6     movl    RCX, R9 # spill
0a9     addl    RCX, #6 # int
0ac     movl    RDX, R9 # spill
0af     addl    RDX, #4 # int
0b2     addl    R9, #2  # int
0b6     movl    R10, R14    # spill
0b9     addl    R10, #22    # int
0bd     movdl   XMM3, R10   # spill
0c2     movl    RDI, R14    # spill
0c5     addl    RDI, #20    # int
0c8     movl    RAX, R14    # spill
0cb     addl    RAX, #32    # int
0ce     movl    RSI, R14    # spill
0d1     addl    RSI, #18    # int
0d4     movl    R13, R14    # spill
0d7     addl    R13, #24    # int
0db     movl    R10, R14    # spill
0de     addl    R10, #26    # int
0e2     movl    [rsp + #40], R10    # spill
0e7     movl    RBP, R14    # spill
0ea     addl    RBP, #28    # int
0ed     imull   RBP, R11    # int
0f1     addl    R14, #30    # int
0f5     imull   R14, [RSP + #36 (32-bit)]   # int
0fb     movl    R10, R8 # spill
0fe     addl    R10, #11    # int
102     movdl   R11, XMM3   # spill
107     imull   R11, R10    # int
10b     movl    [rsp + #44], R11    # spill
110     movl    R10, R8 # spill
113     addl    R10, #10    # int
117     imull   RDI, R10    # int
11b     movl    R11, R8 # spill
11e     addl    R11, #8 # int
122     movdl   R10, XMM2   # spill
127     imull   R10, R11    # int
12b     movl    [rsp + #48], R10    # spill
130     movl    R10, R8 # spill
133     addl    R10, #7 # int
137     movdl   R11, XMM1   # spill
13c     imull   R11, R10    # int
140     movl    [rsp + #52], R11    # spill
145     movl    R11, R8 # spill
148     addl    R11, #6 # int
14c     movdl   R10, XMM4   # spill
151     imull   R10, R11    # int
155     movl    [rsp + #56], R10    # spill
15a     movl    R10, R8 # spill
15d     addl    R10, #5 # int
161     movdl   R11, XMM6   # spill
166     imull   R11, R10    # int
16a     movl    [rsp + #60], R11    # spill
16f     movl    R11, R8 # spill
172     addl    R11, #4 # int
176     imull   RBX, R11    # int
17a     movl    R11, R8 # spill
17d     addl    R11, #3 # int
181     imull   RCX, R11    # int
185     movl    R10, R8 # spill
188     addl    R10, #2 # int
18c     imull   RDX, R10    # int
190     movl    R11, R8 # spill
193     incl    R11 # int
196     imull   R9, R11 # int
19a     addl    R9, [RSP + #32 (32-bit)]    # int
19f     addl    R9, RDX # int
1a2     addl    R9, RCX # int
1a5     addl    R9, RBX # int
1a8     addl    R9, [RSP + #60 (32-bit)]    # int
1ad     addl    R9, [RSP + #56 (32-bit)]    # int
1b2     addl    R9, [RSP + #52 (32-bit)]    # int
1b7     addl    R9, [RSP + #48 (32-bit)]    # int
1bc     movl    R10, R8 # spill
1bf     addl    R10, #9 # int
1c3     imull   R10, RSI    # int
1c7     addl    R10, R9 # int
1ca     addl    R10, RDI    # int
1cd     addl    R10, [RSP + #44 (32-bit)]   # int
1d2     movl    R11, R8 # spill
1d5     addl    R11, #12    # int
1d9     imull   R13, R11    # int
1dd     addl    R13, R10    # int
1e0     movl    R10, R8 # spill
1e3     addl    R10, #13    # int
1e7     imull   R10, [RSP + #40 (32-bit)]   # int
1ed     addl    R10, R13    # int
1f0     addl    RBP, R10    # int
1f3     addl    R14, RBP    # int
1f6     movl    R10, R8 # spill
1f9     addl    R10, #16    # int
1fd     cmpl    R10, #999999985
204     jl     B2   # loop end  P=1.000000 C=7419903.000000

在这里,由于需要保留更多的中间结果,我们观察到更多的“溢出”和对堆栈的更多访问。

因此,问题的答案很简单:2 * (i * i)2 * i * i更快,因为 JIT 生成了更优化的汇编代码。

Java的JIT是个非常有价值的东西,但有的时候它也可能“犯傻”,我们在平时写代码的过程中对于这些点倒也无需刻意去记忆,这本该是编译器自己要做的事情,祝愿Java的编译器越来越好吧。

原文链接:https://pebble-skateboard-d46.notion.site/JAVA-a91ca0b1305e49918efcdd0035a7a6e6

参考资料

https://stackoverflow.com/questions/53452713/why-is-2-i-i-faster-than-2-i-i-in-java

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/596783.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

什么是系统设计 – 学习系统设计

系统设计被定义为为系统的不同组件、接口和模块创建架构并提供有助于在系统中实现这些元素的相应数据的过程。系统设计是任何分布式系统设计背后的核心概念。 系统设计涉及识别数据源&#xff0c;它是描述、创建和规划框架以满足特定业务的必要性和先决条件的直觉。 为什么要…

excel公式名称管理器

1.问题 在日常使用excel的时候&#xff0c;发布一个表格文件&#xff0c;需要限制表格的某列或某行只能从我们提供的选项中选择&#xff0c;自己随便填写视为无效&#xff0c;如下图所示&#xff0c;上午的行程安排只能从"在岗"、"出差"、"病假"…

java面试汇总

JVM内存模型与Java线程内存模型的区别 JVM内存模型描述的是Java虚拟机在执行Java程序时如何管理和使用内存&#xff0c;主体围绕&#xff1a;方法区&#xff08;Method Area&#xff09;、堆&#xff08;Heap&#xff09;、程序计数器&#xff08;Program Counter Register&am…

AI绘图模型不会写字的难题解决了

介绍 大家好&#xff0c;最近有个开源项目比较有意思&#xff0c;解决了图像中不支持带有中文的问题。 https://github.com/tyxsspa/AnyText。 为什么不能带有中文&#xff1f; 数据集局限 Stable Diffusion的训练数据集以英文数据为主&#xff0c;没有大量包含其他语言文本的…

LeetCode-141环形链表 LeetCode-142环形链表二

一、前言 本篇文章在我之前讲完的链表、链表与递归的基础上进行讲解&#xff0c;本次我们以leetcode为例&#xff0c;讲解链表的其他题型&#xff0c;今天我们先了解一下环形链表&#xff0c;这里我们以leetCode141和leetCode142为例。 二、LeetCode141 首先关于这道题&#…

微服务注册中心之Eureka

微服务注册中心之Eureka eureka 搭建集群 版本说明 Spring Boot 2.1.7.RELEASE spring-cloud-starter-netflix-eureka-server Finchley.SR2 spring-boot-starter-security 2.1.7.RELEASE pom.xml 文件 <?xml version"1.0" encoding"UTF-8"?> &l…

游戏缺少emp.dll详细修复教程,快速解决游戏无法启动问题

在现代游戏中&#xff0c;我们经常会遇到一些错误提示&#xff0c;其中之一就是“emp.dll丢失”。emp.dll是一个动态链接库文件&#xff0c;它包含了许多程序运行所需的函数和数据。当一个程序需要调用这些函数时&#xff0c;系统会从emp.dll文件中加载相应的内容。因此&#x…

VSCode上远程调试代码出现的问题

记录一下&#xff1a; 真的是汗流浃背了&#xff0c;师妹叫帮忙如何在VSCode上远程调试代码&#xff0c;一些自己已经经历过的问题&#xff0c;现在已经忘记了。又在网上一顿搜索&#xff0c;这次记录下吧。。。 出现以下问题&#xff1a; 1. 终端界面总是sh-4.4 $ &#xff…

【每日试题】java面试题之中间件

什么是中间件&#xff1f; 中间件是指位于客户端和服务器之间的一层软件&#xff0c;它可以提供一系列的服务&#xff0c;简化了开发和管理复杂的分布式应用系统。 中间件的分类有哪些&#xff1f; 中间件可以分为消息中间件、缓存中间件、数据访问中间件、分布式计算中间件、…

LINUX加固之命令审计

一、前言 在LINUX安全范畴中&#xff0c;安全溯源也是很重要的一个环节。对主机上所有曾操作过的命令详细信息需要有一份记录保存&#xff0c;当系统遭受破坏或者入侵&#xff0c;拿出这份记录&#xff0c;可以帮助定位一些可疑动作。 很多系统通常都会配置安全堡垒机&#xff…

jmeter断言-三种

1.响应断言 substring是指包含就行 不用完全相等 2.json断言 3.持续时间断言

Consule安装与SpringBoot集成

Consule Consul 是由 HashiCorp 开发的一款软件工具&#xff0c;提供了一组功能&#xff0c;用于服务发现、配置管理和网络基础设施自动化。它旨在帮助组织管理现代分布式和微服务架构系统的复杂性。以下是Consul的一些关键方面和功能&#xff1a; 服务发现&#xff1a;Consul…

JS常用数据类型转换

js提供了5中基本数据类型&#xff1a;数字 number 字符串 string 布尔 boolean 空值 null 未定义的 undefined 常用的是数字型和字符串型之间的转换&#xff0c;常用的转换方法如下&#xff1a; 1 数字型转换成字符串型 a) 使用String&#xff08;&#xff09;方…

java设计小分队01

1.开发流程&#xff1a; 编辑&#xff1a;生成.java文件编译&#xff1a;javac命令&#xff0c;生成.class文件运行&#xff1a;java命令 2.标识符下列那个&#xff08;不&#xff09;合法&#xff1a; 除了第一个词小写&#xff0c;其他词首字母大写&#xff1b;java标识符为…

Bash脚本中的分支控制:深入理解Case语句

在编写Bash脚本时&#xff0c;我们经常需要根据不同的条件执行不同的代码块。传统的if-elif-else语句在处理多条件分支时可能会变得冗长和复杂。幸运的是&#xff0c;Bash提供了一个更为简洁的选择结构&#xff1a;case语句。在本文中&#xff0c;我们将深入探讨case语句的使用…

2024第一篇: 架构师成神之路总结,你值得拥有

大家好&#xff0c;我是冰河~~ 很多小伙伴问我进大厂到底需要怎样的技术能力&#xff0c;经过几天的思考和总结&#xff0c;终于梳理出一份相对比较完整的技能清单&#xff0c;小伙伴们可以对照清单提前准备相关的技能&#xff0c;在平时的工作中注意积累和总结。 只要在平时…

仅仅几行 Python 代码,却可帮你快手完成大部分工作

Python 作为一种脚本语言&#xff0c;开发简单&#xff0c;几行代码却能发挥大作用。 本文将介绍几种有趣的 Python 脚本&#xff0c;一定能在你的生活和工作中发挥用处。 自动整理文件和文件夹 手动整理文件和文件夹可能很乏味。这个 Python 脚本可按扩展名类型自动将文件排…

NPC问题

1. P 问题和 NP 问题&#xff1a; P 问题&#xff08;多项式时间可解问题&#xff09;&#xff1a; P 问题是可以在多项式时间内有效解决的问题&#xff0c;即存在一个算法&#xff0c;其运行时间是输入规模的多项式函数。例如&#xff0c;排序算法、搜索算法等都属于 P 问题。…

【DevOps-02】Code编码阶段工具

一、简要说明 在code阶段,我们需要将不同版本的代码存储到一个仓库中,常见的版本控制工具就是SVN或者Git,这里我们采用Git作为版本控制工具,GitLab作为远程仓库。 Git安装安装GitLab配置GitLab登录账户二、Git安装 Git官网 Githttps://git-scm.com/

gin框架实战(一)- HTTP请求参数校验之神器validator

1 快速安装 使用之前&#xff0c;首先要获取validator这个库&#xff1a; $ go get github.com/go-playground/validator/v10 2 功能 golang http 请求参数校验工具&#xff0c;具备复杂参数校验规则。 3 操作符 标记 标记说明 , 多操作符分割 | 或操作 - 跳过字段…