Java 函数调用是传值还是传引用?从字节码角度来看看 !

一个小问题

在开源中国看到这样一则问题

https://www.oschina.net/question/2507499_2244027,其中的变量a前后的输出是什么?

我答错了,我认为传入function的就是main函数中的a,在function中修改了a的地址,因此回到主函数后,a的地址已经变成了function中所赋予的a2的地址,因此经过function处理后a的值已经改变了。 但结果并不是,因为我忽略了Java的基础知识点之一。

Java中传参都是值传递,如果是基本类型,就是对值的拷贝,如果是对象,就是对引用地址的拷贝。

下文将从字节码的角度,分析Java中基本类型传参和对象传参。

基本类型传参

以下是处理类Porcess,代码应该已经能够自解释了。function1是将传参a变成2,function2是初始化int b,赋值为5,然后将b赋值给a。

public class Process {

    public void function3(int a) {
        a = 2;
    }

    public void function4(int a) {
        int b = 5;
        a = b;
    }
}

我们继续看测试类TestPrimitive

public class TestPrimitive {

    public static void main(String[] args) {
        Process process = new Process();
        int age = 18;
        System.out.println(age);
        process.function3(age);
        System.out.println(age);
    }
}

结果是在经过function3的处理后,输出结果是

18
18

修改测试类代码,在经过function4处理后,仍然一致。

18
18

结论: 基本类型的传参,对传参进行修改,不影响原本参数的值。

对象类型传参

以下是处理类Porcess,function1,将参数car的颜色设置成blue。function2,新建了car2,将car2赋值给了参数car。

public class Process {

    public void function1(Car car) {
        car.setColor("blue");
    }

    public void function2(Car car) {
        Car car2 = new Car("black");
        car = car2;
        car.setColor("orange");
    }
}

我们继续看测试类TestReference

public class TestReference {

    public static void main(String[] args) {
        Process process = new Process();
        Car car = new Car("red");
        System.out.println(car);
        process.function1(car);
        System.out.println(car);
    }
}

结果是在经过function1的处理后,输出结果是

Car{color='red'}
Car{color='blue'}

修改测试类,在经过function2的处理后

Car{color='red'}
Car{color='red'}

结论: 对象类型的传参,直接调用传参set方法,可以对原本参数进行修改。如果修改传参的指向地址,调用传参的set方法,无法对原本参数的值进行修改。

综上所述,基本类型的传参,在方法内部是值拷贝,有一个新的局部变量得到这个值,对这个局部变量的修改不影响原来的参数。对象类型的传参,传递的是堆上的地址,在方法内部是有一个新的局部变量得到引用地址的拷贝,对该局部变量的操作,影响的是同一块地址,因此原本的参数也会受影响,反之,若修改局部变量的引用地址,则不会对原本的参数产生任何可能的影响。

上文已经得到结论,我们从JVM的字节码的角度看一下过程是怎么样的。

首先大致JVM的基本结构,对基本类型,和对象存放的位置有一个大致的了解。下图是JVM的基本组件图。

介绍几个基本的组件

  1. 程序计数器: 存储每个线程下一步将执行的JVM指令。
  2. JVM栈(JVM Stack): JVM栈是线程私有的,每个线程创建的同时都会创建JVM栈,JVM栈中存放的为当前线程中局部基本类型的变量(java中定义的八种基本类型:boolean、char、byte、short、int、long、float、double)、部分的返回结果以及Stack Frame(每个方法都会开辟一个自己的栈帧),非基本类型的对象在JVM栈上仅存放一个指向堆上的地址
  3. 堆(heap): JVM用来存储对象实例以及数组值的区域,可以认为Java中所有通过new创建的对象的内存都在此分配,Heap中的对象的内存需要等待GC进行回收。
  4. 方法区(Method Area): 方法区域存放了所加载的类的信息(名称、修饰符等)、类中的静态变量、类中定义为final类型的常量、类中的Field信息、类中的方法信息,当开发人员在程序中通过Class对象中的getName、isInterface等方法来获取信息时,这些数据都来源于方法区域。
  5. 本地方法栈(Native Method Stacks): JVM采用本地方法栈来支持native方法的执行,此区域用于存储每个native方法调用的状态。
  6. 运行时常量池(Runtime Constant Pool): 存放的为类中的固定的常量信息、方法和Field的引用信息等,其空间从方法区域中分配。JVM在加载类时会为每个class分配一个独立的常量池,但是运行时常量池中的字符串常量池是全局共享的。

下图是从另一个角度解析JVM的结构,JVM是基于栈来操作的,每一个线程有自己的操作栈,遇到方法调用时会开辟栈帧,它含有自己的返回值,局部变量表,操作栈,以及对常量池的符号引用。 如果是基本类型,则存放在栈里的是值,如果是对象,存放在栈上是对象在堆上存放的地址。

了解了JVM的基本结构,我们来看一下上述的两种代码,一种是基本类型传参,一种是对象传参,在字节码表现上的不同。 使用javap对字节码进行反编译

javap -verbose Main

基本类型传参字节码

以下是TestPrimitive类在执行function3时的字节码。

public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: new           #2                  // class Process
         3: dup           
         4: invokespecial #3                  // Method Process."<init>":()V
         7: astore_1      
         8: bipush        18
        10: istore_2      
        11: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
        14: iload_2       
        15: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
        18: aload_1       
        19: iload_2       
        20: invokevirtual #6                  // Method Process.function3:(I)V
        23: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
        26: iload_2       
        27: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
        30: return        
      LineNumberTable:
        ...........
      LocalVariableTable:
        Start  Length     Slot  Name          Signature
          0      31         0     args        [Ljava/lang/String;
          8      23         1    process      LProcess;
          11      20        2      age            I

主函数执行时,JVM操作栈会推入主函数栈帧,其中包含了主函数的局部变量表,字节码,返回值等信息。LocalVariableTable就是局部变量表,以0为索引起点,第0个是局部变量String数组 args,第1个是局部变量process,保存新创建的Process对象的引用地址。第2个是局部变量age。在字节码第8行,通过bipush 18,将常量18直接压入操作栈,然后第20行,是调用了process的function3方法,传入了age作为参数。 然后JVM操作栈将function3栈帧推入JVM栈,使得function3栈帧成为当前栈帧,开始执行。

public void function3(int);
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=2
         0: iconst_2      
         1: istore_1      
         2: return        
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
          0       3     0     this   LProcess;
          0       3     1       a      I

字节码显示,通过iconst_2,istore_1,将基本类型2推入栈,并保存在局部变量a中,这里就展示了我们在方法内部的修改都是对function3的局部变量a的值修改,不影响主函数中的a。从主函数的字节码中可以看到,它的值保存的还是第10行,通过istore_2保存到局部变量第2个索引处的18.

如果用图示来表示上述字节码执行过程中,JVM栈,man函数栈帧,function3栈帧内部变化的话,如下图所示。

1.主函数的栈帧会被推入JVM栈,成为当前操作栈。

2.然后进去main函数栈帧,初始化完毕后如下图所示。

3.主要看bipush 18,将基本变量18推入操作栈,基本变量类型是存储在栈帧内部的。

4.然后执行istore_2, 将栈顶出栈,并且保存在局部变量索引2处。

5.然继续执行至18: aload_1,,将创建的process的地址保存在局部变量索引1处,19:iload_2,将局部变量2处保存的基本类型压入栈。

6.然后执行至20:invokevirtula #6,也就是调用function3,进入function3的栈帧。执行0: iconst_2,将常量2推入栈,此时function3的栈帧有一个局部变量1处保存着传入的参数18。

7.继续执行1:istore_1,将栈顶推出,保存在局部变量1处,覆盖了传入的参数18,然后return,将function3函数栈帧弹出JVM栈,继续执行main函数栈帧。

之后会继续执行main函数栈帧,在function3函数栈帧中发生的一切都和Main Stack中的局部变量age的值没有任何关系。

对象类型传参字节码

以下是TestReference类在执行function2时的字节码。

Code:
      stack=3, locals=3, args_size=1
         0: new           #2                  // class Process
         3: dup           
         4: invokespecial #3                  // Method Process."<init>":()V
         7: astore_1      
         8: new           #4                  // class Car
        11: dup           
        12: ldc           #5                  // String red
        14: invokespecial #6                  // Method Car."<init>":(Ljava/lang/String;)V
        17: astore_2      
        18: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
        21: aload_2       
        22: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
        25: aload_1       
        26: aload_2       
        27: invokevirtual #9                  // Method Process.function2:(LCar;)V
        30: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
        33: aload_2       
        34: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
        37: return        
      LocalVariableTable:
        Start  Length  Slot       Name         Signature
          0      38         0     args         [Ljava/lang/String;
          8      30         1     process      LProcess;
          18      20        2     car          LCar;

我们可以通过字节码14-17行,看到局部变量索引2处存放的是Car的实例在堆上的地址,这和基本类型不同,基本类型的值都是直接存放在栈里面的。然后通过字节码第27行将car的引用地址传入function2。接下来我们看看function2的字节码。

public void function2(Car);
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=3, args_size=2
         0: new           #4                  // class Car
         3: dup           
         4: ldc           #5                  // String black
         6: invokespecial #6                  // Method Car."<init>":(Ljava/lang/String;)V
         9: astore_2      
        10: aload_2       
        11: astore_1     
        12: aload_1       
        13: ldc           #7                  // String orange
        15: invokevirtual #3                  // Method Car.setColor:(Ljava/lang/String;)V
        18: return     
      LocalVariableTable:
        Start  Length  Slot  Name       Signature
          0      13     0          this   LProcess;
          0      13     1           car   LCar;
         10       3     2          car2   LCar;

题外话,因为这个是调用具体实例的函数,所以索引0处保存的是实例的引用。索引1保存的是传参car的引用地址,car2保存的是函数内创建的Car实例的地址。字节码0-9,完成了car2的引用地址保存,第10行将Car2的引用地址推入栈,第11行通过astore_1,将栈顶值保存到第一个局部变量,也就是修改了覆盖了局部变量car的引用地址。因此第15行,修改的是car当前引用的地址的实例的参数值。当退出栈帧,回到主函数,主函数的局部变量a保存的引用地址没有改变。

如果用图示来表示上述字节码执行过程中,JVM栈,man函数栈帧,function3栈帧内部变化的话,如下图所示。

1.main函数栈帧和上文测试基本类型传参时的字节码大致类似,不同的是局部变量处。局部变量2处保存的是main函数中新建的Car实例的堆上地址。对象的实际存放都是在堆中,栈帧的局部变量中保存的是他们在堆上的地址。

2.一直执行到调用function2,进入function2栈帧。在执行至9:astore_2时,栈中新创建的Car实例的引用地址出栈,保存在局部变量2处。局部变量1保存的是传参进来的Car实例的引用地址。

3.然后执行至10: aload_2,11:store_1,在这里,1236df被推入栈,然后保存在了局部变量1,覆盖了局部变量car本来的引用地址。

因此,当function2对局部变量2进行相关操作时,影响的都是1236df这块地址,和main函数局部变量car中保存的1235df不是一块地址,所以前后打印结果一致。

测试类TestReference调用function1时,function1没有改变局部变量car的引用地址,保存的仍然是传入的引用地址,所以function1中car进行的操作影响了这块地址保存的内容,导致了前后打印结果不一致。

Code:
      stack=2, locals=2, args_size=2
         0: aload_1       
         1: ldc           #2                  // String blue
         3: invokevirtual #3                  // Method Car.setColor:(Ljava/lang/String;)V
         6: return        
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
         0       7       0    this    LProcess;
         0       7       1     car    LCar;

本文对Java基本类型传参和对象传参,从字节码角度进行了分析,现在不会再搞错了吧~



相关文章

发表评论

Comment form

(*) 表示必填项

还没有评论。

跳到底部
返回顶部