Java 栈内存介绍

     本篇我们了解一下Java的栈内存空间。
     1.我们首先从Intel80386架构下的Linux汇编开始，看看会把什么东西存放在栈中。在开始之前，需要注意一点，Intel80386架构下的linux系统的堆是从高位地址往低位地址增长的。
     我们看一个简单的例子，计算从1加到100，文件存储为test.c

int sum(int max);
int test()
{
    sum(100);
}
int sum(int max)
{
    int result = 0;
    int i;
    for (i=1; i<=max; i++)
    {
        result += i;
    }

    return result;
}

     编译一下，生成test.o

gcc -c test.c

     反汇编一下test.o

objdump -d test.o

     得到如下的汇编代码

00000000 <test>:
0: push %ebp
1: mov %esp,%ebp                                       ;1)
3: sub $0x8,%esp
6: movl $0x64,(%esp)
d: call e <test+0xe>                                       ;2)
12: leave
13: ret                                                        ;3)

00000014 <sum>:
14: push %ebp
15: mov %esp,%ebp
17: sub $0x10,%esp
1a: movl $0x0,0xfffffff8(%ebp)
21: movl $0x1,0xfffffffc(%ebp)                          ;4)
28: jmp 34 <sum+0x20>
2a: mov 0xfffffffc(%ebp),%eax
2d: add %eax,0xfffffff8(%ebp)
30: addl $0x1,0xfffffffc(%ebp)
34: mov 0xfffffffc(%ebp),%eax ;
37: cmp 0x8(%ebp),%eax                               ;5)
3a: jle 2a <sum+0x16>
3c: mov 0xfffffff8(%ebp),%eax
3f: leave
40: ret

    1）push   %ebp
         mov    %esp,%ebp
      标准的函数进入后处理方式，将上一个方法的基址寄存器(ebp)入栈，以备在返回时恢复上一个方法的现场。并将当前的栈顶esp（即当前方法栈的开始地址)设置给ebp（即ebp总是指向当前方法栈的开始位置）
    2）sub    $0x8,%esp
        movl   $0x64,(%esp)
        call   e <test+0xe>
     需要再次提醒的是，栈是从高位地址往低位地址增长的，所以此处是减，从栈中分配8个字节，其中前4个字节预留给方法入参(movl   $0x64,(%esp))，后4个字节预留给返回地址（在call   e <test+0xe>，call指令自动会将下一条指令的地址塞入这个位置），需要注意的是，这里call的目标地址是e(当前指令位置d+1)，是因为这是一个目标文件(.o)，在连接(link)阶段，会自动解析正确的地址，有兴趣可以参考我的另一篇BLOG《Linkers and Loaders初探 》。
     3）leave
          ret
   标准的离开方法时的指令组合，这两条指令会进行返回到上一个方法的现场回复，譬如，恢复上一个方法的ebp/esp，并转向上一个方法的下一条指令的位置。
      4）现在进入到方法sum，同样的，经过标准参数进入处理后，ebp指向当前方法栈的开始位置，而指令（sub    $0x10,%esp）预留了16个字节给当前的局部变量（发现在这里预留给局部变量的空间总是16个字节的倍数，不知道为什么一定要这样子），经过这番折腾后，我们可以看到栈数据的分布大概是如下，有了这个图，后面的程序的理解就比较轻松了。
 
       5)mov    0xfffffffc(%ebp),%eax ;
          cmp    0x8(%ebp),%eax
       这里非常好理解，就是比较i(ebp-4)和入参max(ebp+8)
      2.通过如上程序的分析，我们大概可以知道，Intel80386架构下Linux汇编中，入参、返回方法地址、局部变量会存储到栈中，使用ebp+偏移量可以访问到特定的某个局部变量。JVM汇编与之类似，但有点不同的是，Intel80386的汇编中，计算是通过EAX/EBX等寄存器来进行的，而JVM中则没有这两个寄存器的概念，计算是通过堆来进行的。

      我们看看JVM汇编是如何出来的，首先是Java程序，如上的例子一样

package ray.test;

public class Test
{
    public int test()
    {
        return sum(100);
    }

    public int sum(int max)
    {
        int result = 0;
        int i;
        for (i = 1; i <= max; i++)
        {
            result += i;
        }

        return result;
    }
}

      我们看看JVM汇编结果

public class ray.test.Test extends java.lang.Object{
public ray.test.Test();
Code:
0: aload_0
1: invokespecial java/lang/Object.<init>:()V
4: return

public int test();
Code:
0: aload_0
1: bipush 100                                       ;1)
3: invokevirtual sum:(I)I                          ;2)
6: ireturn

public int sum(int);
Code:
0: iconst_0
1: istore_2
2: iconst_1
3: istore_3                                           ;3)
4: goto 14
7: iload_2
8: iload_3
9: iadd
10: istore_2
11: iinc 3, 1                                        ;4)
14: iload_3
15: iload_1
16: if_icmple 7                                      ;5)
19: iload_2
20: ireturn ;6)
}

      1)  aload_0                   ：将第一个方法参数入栈，第一个参数就是this的地址
           bipush  100              ：将参数值100入栈
      2）invokevirtual   sum:(I)I ：调用sum方法，JVM是基于栈的运算，此处传入的参数就是栈顶部分的数据，即100，（实际上会传递2个参数，一个是this，一个是100，大部分面向对象的语言在转换成面向过程的汇编的过程当中，大体都会是类似的处理方法）
      3）iconst_0                   ：将值0入栈，此指令类似于bipush 0，只是会更高效。JVM对于最常见的0-5，都有一条iconst_x指令。
          istore_2                    ：把第3个局部变量（即result）的值设为当前栈顶值(0)，第2个参数可以理解为ebp偏移4个字节。第1个局部变量是this，第2个局部变量是入参数，
          iconst_1        
          istore_3                    ：与上类似，第4个局部变量为i，设置值为1
     4） iload_2                     ：将第3个局部变量(result)入栈
          iload_3                      ：将第4个局部变量(i)入堆栈
          iadd                         ：将两个栈顶元素相加，并将两个栈顶元素移除，将结果再入栈
          istore_2                     ：将栈顶元素（即相加结果）设到第3个局部变量（即result）
          iinc    3, 1                 ：递增第4个局部变量(i)的值
     5）iload_3                      ：将第4个局部变量(i)的值入栈
          iload_1                      ：将第2个局部变量(max)的值入栈
          if_icmple     7             ：比较栈顶两个值，如果i<=max,则重新进入指令7的位置(对应for循环)
     从如上的指令说明，我们可以看到JVM的指令都是基于栈来进行运算的。为加深运算，我们再举一个数学运算的例子说明。一般，进行数学公式描述的时候，我们比较喜欢使用中缀表达式，譬如：18 * 12 + 17 * 13，而对于JVM这种基于栈运算的汇编来说，采用后缀表达式（逆波兰表达式）描述会更方便：18 12 * 17 13 * +。如下我们采用JVM汇编来进行这个运算

bipush 18
bipush 12
imul
bipush 17
bipush 13
imul
iadd

     我们可以从栈的变迁来理解这个过程，从JVM汇编我们看不出栈是由上自下增长（Intel80386下的linux系统是采用这种方式）还是自下往上增长，我们这里假设是由下往上增长。
      3.从如上的分析过程，我们可以了解到JVM的栈中会存储一些什么东西，以及如何利用堆来进行运算的。除此之外，我们需要知道的是，在JVM中，栈是针对线程的，在线程构造函数中，我们可以看到可以传入栈的大小，需要注意的是，该值对JVM而言只是一个建议，JVM有权选择更合适的值

public Thread(ThreadGroup group, Runnable target, String name,
                  long stackSize) {
    init(group, target, name, stackSize);
}

     当然也可以通过JVM启动参数来指定

-XX:ThreadStackSize=<value>:设置线程的栈大小（字节数）(0表示默认) [Sparc: 512, Solaris Intel: 256, Sparc 64bit: 1024 all others 0]

    一般情况下采用默认的值即可