JVM优化（6）jvm字节码分析

最新推荐文章于 2025-05-11 18:01:30 发布
最新推荐文章于 2025-05-11 18:01:30 发布
阅读量352 收藏 1
点赞数 1
CC 4.0 BY-SA版权
文章标签： GC class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/MyronCham/article/details/84997153

目录：

1、JVM字节码

1.1、通过javap命令查看class文件的字节码内容

2.2、常量池

2.3、描述符

2.3.1、字段描述符

2.3.2、方法描述符

2.4、解读方法字节码

2.5 、研究 i++ 与 ++i 的不同

2.5.1、查看class字节码

2.5.2、对比

2.6、字符串拼接

2.7、小结

1、JVM字节码

对于程序本身的优化，可以借鉴很多前辈们的经验，但是有些时候，在从源码角度方面分析的话，不好鉴别出哪个效率高，如对字符串拼接的操作，是直接“+”号拼接效率高还是使用StringBuilder效率高？
这个时候，就需要通过查看编译好的class文件中字节码，就可以找到答案。
我们都知道，java编写应用，需要先通过javac命令编译成class文件，再通过jvm执行，jvm执行时是需要将class文件中的字节码载入到jvm进行运行的。

1.1、通过javap命令查看class文件的字节码内容

首先，看一个简单的Test1类的代码：

package com.nari.jvm;
public class Test1 {
    public static void main(String[] args) {
        int a = 2;
        int b = 5;
        int c = b ‐ a;
        System.out.println(c);
    }
}

通过javap命令查看class文件中的字节码内容：

javap ‐v Test1.class > Test1.txt
javap用法: javap <options> <classes>
其中, 可能的选项包括:
  ‐help  ‐‐help  ‐?        输出此用法消息
  ‐version                 版本信息
  ‐v  ‐verbose             输出附加信息
  ‐l                       输出行号和本地变量表
  ‐public                  仅显示公共类和成员
  ‐protected               显示受保护的/公共类和成员
  ‐package                 显示程序包/受保护的/公共类
                           和成员 (默认)
  ‐p  ‐private             显示所有类和成员
  ‐c                       对代码进行反汇编
  ‐s                       输出内部类型签名
  ‐sysinfo                 显示正在处理的类的
                           系统信息 (路径, 大小, 日期, MD5 散列)
  ‐constants               显示最终常量
  ‐classpath <path>        指定查找用户类文件的位置
  ‐cp <path>               指定查找用户类文件的位置
  ‐bootclasspath <path>    覆盖引导类文件的位置

查看Test1.txt文件，内容如下：

  Classfile /F:/code/jvm/jvm‐
test/target/classes/com/nari/jvm/Test1.class
  Last modified 2018‐12‐13; size 577 bytes
  MD5 checksum 4214859db3543c0c783ec8a216a4795f
  Compiled from "Test1.java"
public class com.nari.jvm.Test1
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#23         // java/lang/Object."<init>":
()V
   #2 = Fieldref           #24.#25        //
java/lang/System.out:Ljava/io/PrintStream;
   #3 = Methodref          #26.#27        // java/io/PrintStream.println:
(I)V
   #4 = Class              #28            // com/nari/jvm/Test1
   #5 = Class              #29            // java/lang/Object
   #6 = Utf8               <init>
   #7 = Utf8               ()V
   #8 = Utf8               Code
   #9 = Utf8               LineNumberTable
  #10 = Utf8               LocalVariableTable
  #11 = Utf8               this
  #12 = Utf8               Lcom/nari/jvm/Test1;
  #13 = Utf8               main
  #14 = Utf8               ([Ljava/lang/String;)V
  #15 = Utf8               args
  #16 = Utf8               [Ljava/lang/String;
  #17 = Utf8               a
  #18 = Utf8               I
  #19 = Utf8               b
  #20 = Utf8               c
  #21 = Utf8               SourceFile
  #22 = Utf8               Test1.java
  #23 = NameAndType        #6:#7          // "<init>":()V
  #24 = Class              #30            // java/lang/System
  #25 = NameAndType        #31:#32        // out:Ljava/io/PrintStream;
  #26 = Class              #33            // java/io/PrintStream
  #27 = NameAndType        #34:#35        // println:(I)V
  #28 = Utf8               com/nari/jvm/Test1
  #29 = Utf8               java/lang/Object
  #30 = Utf8               java/lang/System
  #31 = Utf8               out
  #32 = Utf8               Ljava/io/PrintStream;
  #33 = Utf8               java/io/PrintStream
  #34 = Utf8               println
  #35 = Utf8               (I)V
{
  public com.nari.jvm.Test1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method
java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/nari/jvm/Test1;
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: iconst_2
         1: istore_1
         2: iconst_5
         3: istore_2
         4: iload_2
         5: iload_1
         6: isub
         7: istore_3
         8: getstatic     #2                  // Field
java/lang/System.out:Ljava/io/PrintStream;
        11: iload_3
        12: invokevirtual #3                  // Method
java/io/PrintStream.println:(I)V
        15: return
      LineNumberTable:
        line 6: 0
        line 7: 2
        line 8: 4
        line 9: 8
        line 10: 15
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      16     0  args   [Ljava/lang/String;
            2      14     1     a   I
            4      12     2     b   I
            8       8     3     c   I
}
SourceFile: "Test1.java"

内容大致分为 4个部分：

  • 第一部分：显示了生成这个class的java源文件、版本信息、生成时间等。
  • 第二部分：显示了该类中所涉及到常量池，共35个常量。
  • 第三部分：显示该类的构造器，编译器自动插入的。
  • 第四部分：显示了main方的信息。（重点关注的）

2.2、常量池

官网文档：
https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.4-140

ConstantType

Value

说明

CONSTANT_Class

7

类或接口的符号引用

CONSTANT_Fieldref

9

字段的符号引用

CONSTANT_Methodref

10

类中方法的符号引用

CONSTANT_InterfaceMethodref

11

接口中方法的符号引用

CONSTANT_String

8

字符串类型常量

CONSTANT_Integer

3

整形常量

CONSTANT_Float

4

浮点型常量

CONSTANT_Long

5

长整型常量

CONSTANT_Double

6

双精度浮点型常量

CONSTANT_NameAndType

12

字段或方法的符号引用

CONSTANT_Utf8

1

UTF-8编码的字符串

CONSTANT_MethodHandle

15

表示方法句柄

CONSTANT_MethodType

16

标志方法类型

CONSTANT_InvokeDynamic

18

表示一个动态方法调用点

2.3、描述符

2.3.1、字段描述符

官网：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2

FieldTypeterm

Type

Interpretation

B

byte

signed byte

C

char

Unicode character code point in the Basic

Multilingual Plane, encoded with UTF-16

D

double

double-precision floating-point value

F

float

single-precision floating-point value

I

int

integer

J

long

long integer

LClassName;

reference

an instance of class ClassName

S

short

signed short

Z

boolean

true or alse

[

reference

one array dimension

2.3.2、方法描述符

官网：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3
示例：
The method descriptor for the method:

Object m(int i, double d, Thread t) {...}

is:

(IDLjava/lang/Thread;)Ljava/lang/Object;

2.4、解读方法字节码

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V  //方法描述，V表示该方法的放回值为
void
    flags: ACC_PUBLIC, ACC_STATIC  // 方法修饰符，public、static的
    Code:
      // stack=2,操作栈的大小为2、locals=4，本地变量表大小，args_size=1, 参数
的个数
      stack=2, locals=4, args_size=1
         0: iconst_2  //将数字2值压入操作栈，位于栈的最上面
         1: istore_1  //从操作栈中弹出一个元素(数字2)，放入到本地变量表中，位
于下标为1的位置（下标为0的是this）
         2: iconst_5  //将数字5值压入操作栈，位于栈的最上面
         3: istore_2  //从操作栈中弹出一个元素(5)，放入到本地变量表中，位于第
下标为2个位置
         4: iload_2  //将本地变量表中下标为2的位置元素压入操作栈（5）
         5: iload_1  //将本地变量表中下标为1的位置元素压入操作栈（2）
         6: isub  //操作栈中的2个数字相减
         7: istore_3 // 将相减的结果压入到本地本地变量表中，位于下标为3的位置
         // 通过#2号找到对应的常量，即可找到对应的引用      
         8: getstatic     #2                  // Field
java/lang/System.out:Ljava/io/PrintStream;
        11: iload_3 //将本地变量表中下标为3的位置元素压入操作栈（3）
        // 通过#3号找到对应的常量，即可找到对应的引用，进行方法调用
        12: invokevirtual #3                  // Method
java/io/PrintStream.println:(I)V
        15: return //返回
      LineNumberTable:  //行号的列表
        line 6: 0
        line 7: 2
        line 8: 4
        line 9: 8
        line 10: 15
      LocalVariableTable: // 本地变量表
        Start  Length  Slot  Name   Signature
            0      16     0  args   [Ljava/lang/String;
            2      14     1     a   I
            4      12     2     b   I
            8       8     3     c   I
}
SourceFile: "Test1.java"

2.5 、研究 i++ 与 ++i 的不同

我们都知道，i++表示，先返回再+1，++i表示，先+1再返回。它的底层是怎么样的呢? 我们一起探究下。
编写测试代码：

public class Test2 {
    public static void main(String[] args) {
        new Test2().method1();
        new Test2().method2();
    }
    public void method1(){
        int i = 1;
        int a = i++;
        System.out.println(a); //打印1
    }
    public void method2(){
        int i = 1;
        int a = ++i;
        System.out.println(a);//打印2
    }
}

2.5.1、查看class字节码

 Classfile /F:/code/jvm/jvm‐
test/target/classes/com/nari/jvm/Test2.class
  MD5 checksum 901660fc11c43b6daadd0942150960ed
  Compiled from "Test2.java"
public class com.nari.jvm.Test2
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #8.#27         // java/lang/Object."<init>":
()V
   #2 = Class              #28            // com/nari/jvm/Test2
   #3 = Methodref          #2.#27         // com/nari/jvm/Test2."
<init>":()V
   #4 = Methodref          #2.#29         // com/nari/jvm/Test2.method1:
()V
   #5 = Methodref          #2.#30         // com/nari/jvm/Test2.method2:
()V
   #6 = Fieldref           #31.#32        //
java/lang/System.out:Ljava/io/PrintStream;
   #7 = Methodref          #33.#34        // java/io/PrintStream.println:
(I)V
   #8 = Class              #35            // java/lang/Object
   #9 = Utf8               <init>
  #10 = Utf8               ()V
  #11 = Utf8               Code
  #12 = Utf8               LineNumberTable
  #13 = Utf8               LocalVariableTable
  #14 = Utf8               this
  #15 = Utf8               Lcom/nari/jvm/Test2;
  #16 = Utf8               main
  #17 = Utf8               ([Ljava/lang/String;)V
  #18 = Utf8               args
  #19 = Utf8               [Ljava/lang/String;
  #20 = Utf8               method1
  #21 = Utf8               i
  #22 = Utf8               I
  #23 = Utf8               a
  #24 = Utf8               method2
  #25 = Utf8               SourceFile
  #26 = Utf8               Test2.java
  #27 = NameAndType        #9:#10         // "<init>":()V
  #28 = Utf8               com/nari/jvm/Test2
  #29 = NameAndType        #20:#10        // method1:()V
  #30 = NameAndType        #24:#10        // method2:()V
  #31 = Class              #36            // java/lang/System
  #32 = NameAndType        #37:#38        // out:Ljava/io/PrintStream;
  #33 = Class              #39            // java/io/PrintStream
  #34 = NameAndType        #40:#41        // println:(I)V
  #35 = Utf8               java/lang/Object
  #36 = Utf8               java/lang/System
  #37 = Utf8               out
  #38 = Utf8               Ljava/io/PrintStream;
  #39 = Utf8               java/io/PrintStream
  #40 = Utf8               println
  #41 = Utf8               (I)V
{
  public com.nari.jvm.Test2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method
java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/nari/jvm/Test2;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: new           #2                  // class
com/nari/jvm/Test2
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
          7: invokevirtual #4                  // Method method1:()V
        10: new           #2                  // class
com/nari/jvm/Test2
        13: dup
        14: invokespecial #3                  // Method "<init>":()V
        17: invokevirtual #5                  // Method method2:()V
        20: return
      LineNumberTable:
        line 6: 0
        line 7: 10
        line 8: 20
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      21     0  args   [Ljava/lang/String;

  public void method1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: iconst_1
         1: istore_1
         2: iload_1
         3: iinc          1, 1
         6: istore_2
         7: getstatic     #6                  // Field
java/lang/System.out:Ljava/io/PrintStream;
        10: iload_2
        11: invokevirtual #7                  // Method
java/io/PrintStream.println:(I)V
        14: return
      LineNumberTable:
        line 11: 0
        line 12: 2
        line 13: 7
        line 14: 14
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      15     0  this   Lcom/nari/jvm/Test2;
            2      13     1     i   I
            7       8     2     a   I
      public void method2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: iconst_1
         1: istore_1
         2: iinc          1, 1
         5: iload_1
         6: istore_2
         7: getstatic     #6                  // Field
java/lang/System.out:Ljava/io/PrintStream;
        10: iload_2
        11: invokevirtual #7                  // Method
java/io/PrintStream.println:(I)V
        14: return
      LineNumberTable:
        line 17: 0
        line 18: 2
        line 19: 7
        line 20: 14
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      15     0  this   Lcom/nari/jvm/Test2;
            2      13     1     i   I
            7       8     2     a   I
}
SourceFile: "Test2.java"

2.5.2、对比

i++：

0: iconst_1  //将数字1压入到操作栈
1: istore_1  //将数字1从操作栈弹出，压入到本地变量表中，下标为1
2: iload_1   //从本地变量表中获取下标为1的数据，压入到操作栈中
3: iinc          1, 1 // 将本地变量中的1，再+1
6: istore_2  // 将数字1从操作栈弹出，压入到本地变量表中，下标为2
7: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
10: iload_2   //从本地变量表中获取下标为2的数据，压入到操作栈中
11: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
14: return

++i：

0: iconst_1  //将数字1压入到操作栈
1: istore_1  //将数字1从操作栈弹出，压入到本地变量表中，下标为1
2: iinc          1, 1// 将本地变量中的1，再+1
5: iload_1  //从本地变量表中获取下标为1的数据（2），压入到操作栈中
6: istore_2 //将数字2从操作栈弹出，压入到本地变量表中，下标为2
7: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
10: iload_2 //从本地变量表中获取下标为2的数据（2），压入到操作栈中
11: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
14: return

区别：
i++

  • 只是在本地变量中对数字做了相加，并没有将数据压入到操作栈
  • 将前面拿到的数字 1，再次从操作栈中拿到，压入到本地变量中

++i

  • 将本地变量中的数字做了相加，并且将数据压入到操作栈
  • 将操作栈中的数据，再次压入到本地变量中

小结：可以通过查看字节码的方式对代码的底层做研究，探究其原理。

2.6、字符串拼接

字符串的拼接在开发过程中使用是非常频繁的，常用的方式有三种：

  • + 号拼接： str+"456"
  • StringBuilder 拼接
  • StringBuffer拼接

StringBuffer是保证线程安全的，效率是比较低的，我们更多的是使用场景是不会涉及到线程安全的问题的，所以更多的时候会选择StringBuilder，效率会高一些。
那么，问题来了，StringBuilder和“+”号拼接，哪个效率高呢？接下来我们通过字节码的方式进行探究。
首先，编写个示例：

package com.nari.jvm;
public class Test3 {
    public static void main(String[] args) {
        new Test3().m1();
        new Test3().m2();
    }
    public void m1(){
        String s1 = "123";
        String s2 = "456";
        String s3 = s1 + s2;
        System.out.println(s3);
    }
    public void m2(){
        String s1 = "123";
        String s2 = "456";
        StringBuilder sb = new StringBuilder();
        sb.append(s1);
        sb.append(s2);
        String s3 = sb.toString();
        System.out.println(s3);
    }
}

查看 Test3.class的字节码:

Classfile /F:/code/jvm/jvm‐test/target/classes/com/nari/jvm/Test3.class
  MD5 checksum b3f7629e7e37768b9b5581be01df40d6
  Compiled from "Test3.java"
public class com.nari.jvm.Test3
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #14.#36        // java/lang/Object."<init>":
()V
   #2 = Class              #37            // com/nari/jvm/Test3
   #3 = Methodref          #2.#36         // com/nari/jvm/Test3."
<init>":()V
   #4 = Methodref          #2.#38         // com/nari/jvm/Test3.m1:()V
   #5 = Methodref          #2.#39         // com/nari/jvm/Test3.m2:()V
   #6 = String             #40            // 123
   #7 = String             #41            // 456
   #8 = Class              #42            // java/lang/StringBuilder
   #9 = Methodref          #8.#36         // java/lang/StringBuilder."
<init>":()V
  #10 = Methodref          #8.#43         //
java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #11 = Methodref          #8.#44         //
java/lang/StringBuilder.toString:()Ljava/lang/String;
  #12 = Fieldref           #45.#46        //
java/lang/System.out:Ljava/io/PrintStream;
  #13 = Methodref          #47.#48        // java/io/PrintStream.println:
(Ljava/lang/String;)V
  #14 = Class              #49            // java/lang/Object
  #15 = Utf8               <init>
  #16 = Utf8               ()V
  #17 = Utf8               Code
  #18 = Utf8               LineNumberTable
  #19 = Utf8               LocalVariableTable
  #20 = Utf8               this
  #21 = Utf8               Lcom/nari/jvm/Test3;
  #22 = Utf8               main
  #23 = Utf8               ([Ljava/lang/String;)V
  #24 = Utf8               args
  #25 = Utf8               [Ljava/lang/String;
  #26 = Utf8               m1
  #27 = Utf8               s1
  #28 = Utf8               Ljava/lang/String;
  #29 = Utf8               s2
  #30 = Utf8               s3
  #31 = Utf8               m2
  #32 = Utf8               sb
  #33 = Utf8               Ljava/lang/StringBuilder;
  #34 = Utf8               SourceFile
  #35 = Utf8               Test3.java
  #36 = NameAndType        #15:#16        // "<init>":()V
  #37 = Utf8               com/nari/jvm/Test3
  #38 = NameAndType        #26:#16        // m1:()V
  #39 = NameAndType        #31:#16        // m2:()V
  #40 = Utf8               123
  #41 = Utf8               456
  #42 = Utf8               java/lang/StringBuilder
  #43 = NameAndType        #50:#51        // append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #44 = NameAndType        #52:#53        // toString:
()Ljava/lang/String;
  #45 = Class              #54            // java/lang/System
  #46 = NameAndType        #55:#56        // out:Ljava/io/PrintStream;
  #47 = Class              #57            // java/io/PrintStream
  #48 = NameAndType        #58:#59        // println:
(Ljava/lang/String;)V
  #49 = Utf8               java/lang/Object
  #50 = Utf8               append
  #51 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #52 = Utf8               toString
  #53 = Utf8               ()Ljava/lang/String;
  #54 = Utf8               java/lang/System
  #55 = Utf8               out
  #56 = Utf8               Ljava/io/PrintStream;
  #57 = Utf8               java/io/PrintStream
  #58 = Utf8               println
  #59 = Utf8               (Ljava/lang/String;)V
{
  public com.nari.jvm.Test3();
  descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method
java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/nari/jvm/Test3;
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: new           #2                  // class
com/nari/jvm/Test3
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: invokevirtual #4                  // Method m1:()V
        10: new           #2                  // class
com/nari/jvm/Test3
        13: dup
        14: invokespecial #3                  // Method "<init>":()V
        17: invokevirtual #5                  // Method m2:()V
        20: return
      LineNumberTable:
        line 6: 0
        line 7: 10
        line 8: 20
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      21     0  args   [Ljava/lang/String;
  public void m1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
         0: ldc           #6                  // String 123
         2: astore_1
         3: ldc           #7                  // String 456
         5: astore_2
         6: new           #8                  // class
java/lang/StringBuilder
         9: dup
        10: invokespecial #9                  // Method
java/lang/StringBuilder."<init>":()V
        13: aload_1
        14: invokevirtual #10                 // Method
java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;
        17: aload_2
        18: invokevirtual #10                 // Method
java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;
        21: invokevirtual #11                 // Method
java/lang/StringBuilder.toString:()Ljava/lang/String;
        24: astore_3
        25: getstatic     #12                 // Field
java/lang/System.out:Ljava/io/PrintStream;
        28: aload_3
        29: invokevirtual #13                 // Method
java/io/PrintStream.println:(Ljava/lang/String;)V
        32: return
      LineNumberTable:
        line 11: 0
        line 12: 3
        line 13: 6
        line 14: 25
        line 15: 32
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      33     0  this   Lcom/nari/jvm/Test3;
            3      30     1    s1   Ljava/lang/String;
            6      27     2    s2   Ljava/lang/String;
           25       8     3    s3   Ljava/lang/String;
  
  public void m2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=5, args_size=1
         0: ldc           #6                  // String 123
         2: astore_1
         3: ldc           #7                  // String 456
         5: astore_2
         6: new           #8                  // class
java/lang/StringBuilder
         9: dup
        10: invokespecial #9                  // Method
java/lang/StringBuilder."<init>":()V
        13: astore_3
        14: aload_3
        15: aload_1
        16: invokevirtual #10                 // Method
java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;
        19: pop
        20: aload_3
        21: aload_2
        22: invokevirtual #10                 // Method
java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;
        25: pop
        26: aload_3
        27: invokevirtual #11                 // Method
java/lang/StringBuilder.toString:()Ljava/lang/String;
        30: astore        4
        32: getstatic     #12                 // Field
java/lang/System.out:Ljava/io/PrintStream;
        35: aload         4
        37: invokevirtual #13                 // Method
java/io/PrintStream.println:(Ljava/lang/String;)V
        40: return
      LineNumberTable:
        line 18: 0
        line 19: 3
        line 20: 6
        line 21: 14
        line 22: 20
        line 23: 26
        line 24: 32
        line 25: 40
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      41     0  this   Lcom/nari/jvm/Test3;
            3      38     1    s1   Ljava/lang/String;
            6      35     2    s2   Ljava/lang/String;
           14      27     3    sb   Ljava/lang/StringBuilder;
           32       9     4    s3   Ljava/lang/String;
}
SourceFile: "Test3.java"

从解字节码中可以看出， m1()方法源码中是使用+号拼接，但是在字节码中也被编译成了StringBuilder方式。
所以，可以得出结论，字符串拼接，+号和StringBuilder是相等的，效率一样。
接下来，我们再看一个案例：

package com.nari.jvm;
public class Test4 {
    public static void main(String[] args) {
        new Test4().m1();
        new Test4().m2();
    }
    public void m1(){
        String str = "";
        for (int i = 0; i < 5; i++) {
            str = str + i;
        }
        System.out.println(str);
    }
    public void m2(){
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            sb.append(i);
        }
        System.out.println(sb.toString());
    }
}

m1() 与 m2() 哪个方法的效率高？
依然是通过字节码的方式进行探究。

  Classfile /F:/code/jvm/jvm‐
test/target/classes/com/nari/jvm/Test4.class
  MD5 checksum f87a55446b8b6cd88b6e54bd5edcc9dc
  Compiled from "Test4.java"
public class com.nari.jvm.Test4
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #14.#39        // java/lang/Object."<init>":
()V
   #2 = Class              #40            // com/nari/jvm/Test4
   #3 = Methodref          #2.#39         // com/nari/jvm/Test4."
<init>":()V
   #4 = Methodref          #2.#41         // com/nari/jvm/Test4.m1:()V
   #5 = Methodref          #2.#42         // com/nari/jvm/Test4.m2:()V
   #6 = String             #43            //
   #7 = Class              #44            // java/lang/StringBuilder
   #8 = Methodref          #7.#39         // java/lang/StringBuilder."
<init>":()V
   #9 = Methodref          #7.#45         //
java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #10 = Methodref          #7.#46         //
java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
  #11 = Methodref          #7.#47         //
java/lang/StringBuilder.toString:()Ljava/lang/String;
  #12 = Fieldref           #48.#49        //
java/lang/System.out:Ljava/io/PrintStream;
  #13 = Methodref          #50.#51        // java/io/PrintStream.println:
(Ljava/lang/String;)V
  #14 = Class              #52            // java/lang/Object
  #15 = Utf8               <init>
  #16 = Utf8               ()V
  #17 = Utf8               Code
  #18 = Utf8               LineNumberTable
  #19 = Utf8               LocalVariableTable
  #20 = Utf8               this
  #21 = Utf8               Lcom/nari/jvm/Test4;
  #22 = Utf8               main
  #23 = Utf8               ([Ljava/lang/String;)V
  #24 = Utf8               args
  #25 = Utf8               [Ljava/lang/String;
  #26 = Utf8               m1
  #27 = Utf8               i
  #28 = Utf8               I
  #29 = Utf8               str
  #30 = Utf8               Ljava/lang/String;
  #31 = Utf8               StackMapTable
  #32 = Class              #53            // java/lang/String
  #33 = Utf8               m2
  #34 = Utf8               sb
  #35 = Utf8               Ljava/lang/StringBuilder;
  #36 = Class              #44            // java/lang/StringBuilder
  #37 = Utf8               SourceFile
  #38 = Utf8               Test4.java
  #39 = NameAndType        #15:#16        // "<init>":()V
  #40 = Utf8               com/nari/jvm/Test4
  #41 = NameAndType        #26:#16        // m1:()V
  #42 = NameAndType        #33:#16        // m2:()V
  #43 = Utf8
  #44 = Utf8               java/lang/StringBuilder
  #45 = NameAndType        #54:#55        // append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #46 = NameAndType        #54:#56        // append:
(I)Ljava/lang/StringBuilder;
  #47 = NameAndType        #57:#58        // toString:
()Ljava/lang/String;
  #48 = Class              #59            // java/lang/System
  #49 = NameAndType        #60:#61        // out:Ljava/io/PrintStream;
  #50 = Class              #62            // java/io/PrintStream
  #51 = NameAndType        #63:#64        // println:
(Ljava/lang/String;)V
  #52 = Utf8               java/lang/Object
  #53 = Utf8               java/lang/String
  #54 = Utf8               append
  #55 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #56 = Utf8               (I)Ljava/lang/StringBuilder;
  #57 = Utf8               toString
  #58 = Utf8               ()Ljava/lang/String;
  #59 = Utf8               java/lang/System
  #60 = Utf8               out
  #61 = Utf8               Ljava/io/PrintStream;
  #62 = Utf8               java/io/PrintStream
  #63 = Utf8               println
  #64 = Utf8               (Ljava/lang/String;)V
{
  public com.nari.jvm.Test4();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method
java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/nari/jvm/Test4;
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: new           #2                  // class
com/nari/jvm/Test4
         3: dup
         4: invokespecial #3                  // Method "<init>":()V
         7: invokevirtual #4                  // Method m1:()V
        10: new           #2                  // class
com/nari/jvm/Test4
        13: dup
        14: invokespecial #3                  // Method "<init>":()V
        17: invokevirtual #5                  // Method m2:()V
        20: return
      LineNumberTable:
        line 6: 0
        line 7: 10
        line 8: 20
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      21     0  args   [Ljava/lang/String;
  public void m1();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: ldc           #6                  // String
         2: astore_1  // 将空字符串压入到本地变量表中的下标为1的位置
         3: iconst_0  // 将数字0压入操作栈顶
         4: istore_2  // 将栈顶数字0压入到本地变量表中的下标为2的位置
         5: iload_2  // 将本地变量中下标为2的数字0压入操作栈顶
         6: iconst_5 // 将数字5压入操作栈顶
         7: if_icmpge     35  //比较栈顶两int型数值大小，当结果大于等于0时跳
转到35
        10: new           #7                  // class
java/lang/StringBuilder
        13: dup  //复制栈顶数值并将复制值压入栈顶(数字5)
        14: invokespecial #8                  // Method
java/lang/StringBuilder."<init>":()V
        17: aload_1
        18: invokevirtual #9                  // Method
java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;
        21: iload_2 //将本地变量中下标为2的数字0压入操作栈顶
        22: invokevirtual #10                 // Method
java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
        25: invokevirtual #11                 // Method
java/lang/StringBuilder.toString:()Ljava/lang/String;
        28: astore_1
        29: iinc          2, 1
        32: goto          5
        35: getstatic     #12                 // Field
java/lang/System.out:Ljava/io/PrintStream;
        38: aload_1
        39: invokevirtual #13                 // Method
java/io/PrintStream.println:(Ljava/lang/String;)V
        42: return
      LineNumberTable:
        line 11: 0
        line 12: 3
        line 13: 10
        line 12: 29
        line 15: 35
        line 16: 42
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            5      30     2     i   I
            0      43     0  this   Lcom/nari/jvm/Test4;
            3      40     1   str   Ljava/lang/String;
      StackMapTable: number_of_entries = 2
        frame_type = 253 /* append */
          offset_delta = 5
          locals = [ class java/lang/String, int ]
        frame_type = 250 /* chop */
          offset_delta = 29
  public void m2();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: new           #7                  // class
java/lang/StringBuilder
         3: dup
         4: invokespecial #8                  // Method
java/lang/StringBuilder."<init>":()V
         7: astore_1
         8: iconst_0
         9: istore_2
        10: iload_2
        11: iconst_5
        12: if_icmpge     27
        15: aload_1
        16: iload_2
        17: invokevirtual #10                 // Method
java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
        20: pop
        21: iinc          2, 1
        24: goto          10
        27: getstatic     #12                 // Field
java/lang/System.out:Ljava/io/PrintStream;
        30: aload_1
        31: invokevirtual #11                 // Method
java/lang/StringBuilder.toString:()Ljava/lang/String;
        34: invokevirtual #13                 // Method
java/io/PrintStream.println:(Ljava/lang/String;)V
        37: return
      LineNumberTable:
        line 19: 0
        line 20: 8
        line 21: 15
        line 20: 21
        line 23: 27
        line 24: 37
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
           10      17     2     i   I
            0      38     0  this   Lcom/nari/jvm/Test4;
            8      30     1    sb   Ljava/lang/StringBuilder;
      StackMapTable: number_of_entries = 2
        frame_type = 253 /* append */
          offset_delta = 10
          locals = [ class java/lang/StringBuilder, int ]
        frame_type = 250 /* chop */
          offset_delta = 16
}
SourceFile: "Test4.java"

可以看到， m1()方法中的循环体内，每一次循环都会创建StringBuilder对象，效率低于m2()方法。

2.7、小结

使用字节码的方式可以很好查看代码底层的执行，从而可以看出哪些实现效率高，哪些实现效率低。可以更好的对我们的代码做优化。让程序执行效率更高。

 

 

一棵树～
关注
极致优化之道-JVM字节码调优全揭秘
w风雨无阻w的专栏
05-27 1408
以上就是本文关于JVM字节码优化的主要内容。后续我还会为您分享更多实战技巧，一同探索字节码优化的广阔领域，为编写高性能Java程序插上腾飞的翅膀!让我们拭目以待!
字节码技术修改java类_JVM性能优化--字节码技术
weixin_39686192的博客
02-24 362
一、字节码技术应用场景AOP技术、Lombok去除重复代码插件、动态修改class文件等二、字节技术优势Java字节码增强指的是在Java字节码生成之后，对其进行修改，增强其功能，这种方式相当于对应用程序的二进制文件进行修改。Java字节码增强主要是为了减少冗余代码，提高性能等。实现字节码增强的主要步骤为：1、修改字节码 在内存中获取到原来的字节码，然后通过一些工具(如 ASM，Javaasist...
JVM虚拟机中对字节码优化的策略
张天疯的专栏
03-18 1956
Java Web 2.0架构开发与项目实战主要内容介绍http://www.china-pub.com/48443&ref=ps server jvm和client jvm对字节码优化的策略不同：  Ø         Client主要优化对用户交互的响应速度  Ø         Server主要优化后台运行的代码。 使用server模式可以提高性能，启动比client模式慢，长
JVM——Java字节码基础
最新发布
从知识输入到知识输出
05-11 1640
JVM——Java字节码基础：从栈模型到指令集的全面剖析
JVM字节码
kobejayandy的专栏
11-02 1033
栈和局部变量操作  将常量压入栈的指令  aconst_null         将null对象引用压入栈  iconst_m1         将int类型常量-1压入栈  iconst_0         将int类型常量0压入栈  iconst_1         将int类型常量1压入栈  iconst_2         将int类型常量2压入栈  iconst_3    
JVM（4） 字节码技术+运行期优化
BaiHang111的博客
06-29 319
类文件结构 、字节码指令、语法糖 即时编译、逃逸分析（Escape Analysis）、方法内联
JVM优化3(Tomcat参数调优,JVM参数调优,jvm字节码,代码优化).pdf
01-08
本篇文件内容主要介绍了JVM优化的第三部分，重点围绕Tomcat参数调优、JVM参数调优、JVM字节码优化以及代码优化等几个方面。下面是针对这些知识点的详细解释： 1. Tomcat参数调优 在Tomcat参数调优部分，首先介绍了...
从ES的JVM配置起步思考JVM常见参数优化
张彦峰的博客
12-03 9万+
Java 8目前仍然是许多企业中主要使用的版本之一，尤其是对于比较保守的公司。在过去，CMS (Concurrent Mark-Sweep) 垃圾回收器在Java 8中是一种常见选择，因为它在某些场景下能够提供较好的性能。然而，随着Java版本的不断更新，一些旧的特性和组件被淘汰或替代，比如CMS。Java 14中正式废弃了CMS，而新的垃圾回收器，如ZGC和G1，逐渐成为了主流选择。ZGC和G1在处理大内存堆和低停顿时间方面表现出色，适用于现代应用程序的需求。
JVM优化3(Tomcat参数调优,JVM参数调优,jvm字节码,代码优化).zip
01-09
这个压缩包文件"JVM优化3(Tomcat参数调优,JVM参数调优,jvm字节码,代码优化).zip"显然包含了关于如何优化Java应用程序运行效率的四个主要方面：Tomcat服务器的参数调整、JVM参数调优、JVM字节码理解和优化以及代码...
JVM性能优化（五）源码图解jvm字节码
01-20
一、前言 前面我们通过tomcat本身的参数以及jvm的参数对tomcat做了优化，详情查看：tomcat优化...这个时候，就需要通过查看编译好的class文件中的字节码，就可以找到答案。 我们都知道，java编写应用，需要先通过javac
【8】JVM-字节码技术
热门推荐
19年的努力，并不是说说而已！
12-09 12万+
目录 知识点1:应用场景 知识点2:字节技术优势 知识点3:常见的字节码操作类库 1、BCEL 2、ASM 3、CGLB 4、javassist （1）Javassist优势 （2）avassist的局限性 （3）使用Javassist创建类 （4）使用Javassist修改类文件信息 知识点1:应用场景 AOP技术、Lombok去除重复代码插件、动态修改class文件等...
JVM字节码分析
冰淇淋真好吃
07-13 1412
字节码实战 一、字节码 创建 Test.java 类 public class Test { public int a = 3; static Integer si = 6; String s = "Hello World!"; public static void main (String arg[]){ Test test = new Test(); test.a = 8; si = 9; } pub
jvm字节码结构解析
test1_12的博客
10-10 258
1.概述: 字节码文件里是什么？ 源代码经过编译器编译之后便会生成一个字节码文件，字节码是一种二进制的类文件，它的内容是JVM的指令，而不像C、C++经由编译器直接生成机器码。 什么是字节码指令(bytecode)? Java虚拟机的指令由一个字节长度的、代表着某种特定操作含义的操作码(opcode)以及跟随其后 的零至多个代表此操作所需参数的操作数(operand)所构成。虚拟机中许多指令并不包含操作数，只有一个操作码。 2. 前端...
JVM 字节码解析过程
wanger5354的博客
01-20 417
概述概述本文主要是基于 .class 文件，进行分析 .class 文件的内容。这部分个人觉得主要是属于设计机构拓展的内容，大家可以一起来学习一下 Java 字节码的设计结构以及感受一下设计者的设计。class 类文件结构Java 提供 javap 命令可以分析字节码文件，我们可以使用 javap -verbose 命令分析一个字节码文件时， 将会分析该字节码文件的魔数、版本号、常量池、类信息、类的构造方法、类中的方法信息、类变量与成员变量等信息。一个简单的 Java 代码public class
JVM是如何优化代码的
HongYu012的博客
02-28 263
本文概述了HotspotJVM用于提高性能的一些优化技术。首先，我将给出一个小例子，说明我在编写一个简单的基准测试时是如何遇到这些优化的。然后用一个简短的例子解释每个优化，最后给出一些如何分析自己代码的指针。 背景 很久以前，我用Java编写了一个简单的度量库，并使用了类似的实现。我希望他们的表现可以与之媲美，尽管有一点优势。在对这两个库进行基准测试后，我发现Java的速度要快得多。对于这样一件简单的事情来说，这没有多大意义，所以我研究了这两个库的运行时行为，并注意到Go实现大部分时间都在等待获取和释放
性能优化-JVM字节码
逍遥云恋
01-15 594
2、JVM字节码 前面我们通过tomcat本身的参数以及jvm的参数对tomcat做了优化，其实要想将应用程 序跑的更快、效率更高，除了对tomcat容器以及jvm优化外，应用程序代码本身如果写的效率不高的，那么也是不行的，所以，对于程序本身的优化也就很重要了。 对于程序本身的优化，可以借鉴很多前辈们的经验，但是有些时候，在从源码角度方面 分析的话，不好鉴别出哪个效率高，如对字符串拼接的操作，是...
java 虚拟机字节码指令表
GeekJunz
07-19 1315
字节码 助记符 指令含义 0x00 nop 什么都不做。 0x01 aconst_null 将 null 推送至栈顶。 0x02 iconst_m1 将 int 型-1 推送至栈顶。 0x03 iconst_0 将 int 型 0 推送至栈顶。 0x04 iconst_1 将 int 型 1 推送至...
jvm3--字节码指令|编译器优化｜运行器优化
shining曙光的博客
12-08 211
1、mat分析GCroot
性能优化专题 - JVM 性能优化 - 03 - 字节码执行引擎
✎ℳ๓₯㎕...雲淡風輕
12-20 796
面向Java程序员，衡量其水平的不单单是CRUD，更多的往往是性能优化的经验：包括代码优化、Tomcat优化、MySql优化、JVM优化等问题。在本专题，我将带大家一起走进JAVA性能优化实战，揭开其神秘面纱，让你升职加薪不再是梦想！
JVM性能优化：深入理解字节码解析
了解和利用JVM字节码分析是程序性能优化的重要手段，它帮助我们发现代码的潜在瓶颈，并据此调整代码实现，提升整体系统的执行效率。同时，这也要求开发者具备一定的底层理解和调试技巧，以便在代码优化时做出明智的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值