java栈组成_Java栈与栈上分配

一. java栈：

java栈是一块线程私有的内存空间。如果说，java堆和程序数据密切相关，那么java栈就是和线程执行密切相关的。线程执行的基本行为是函数调用,每次函数调用的数据都是通过Java栈传递的。

java heap,java stack 与Javametaspace之间的关系：

00001.png

特点：

线程私有

栈由一系列帧组成(因此Java栈也叫做帧栈)

帧保存一个方法的局部变量、操作数栈、常量池指针

每一次方法调用创建一个帧，并压栈

1.栈的结构和组成：

1)栈的结构:

这是一块先进后出的数据结构，只支持出栈和入栈两种操作。在java栈中保存的主要内容是栈帧。每一次函数调用都会有一个相应的栈帧入栈，每个函数调用结束，都有一个栈帧弹出java栈。当前正在执行的函数对应的栈就是当前的帧(位于栈顶)。

每个栈帧中，至少包含局部变量表，操作数栈和帧数据区几个部分。

注意由于每次函数调用都会生成栈帧并占有一定的栈空间。因此如果栈空间不足，函数调用就无法进行下去。系统就会抛出StackOverflowOver栈溢出的错误。例如递归时，会有很多栈帧入栈。jvm提供了-Xss来指定线程的最大栈空间，这个参数决定了函数调用的深度。

2)栈组成：

栈由栈帧组成，栈帧由局部变量表，操作数栈，帧数据区组成。

局部变量表：

用于保存函数的参数(实参)变量和局部变量。局部变量表中的变量只在当前函数调用中有效，当函数调用结束后，随着函数栈帧的销毁，局部变量表也会随之销毁。

操作数栈：

栈帧的一部分，也是个先入先出的数据结构。用于计算过程的中间结果，同时作为计算过程中变量临时的存储空间。

public static int add(int a,int b){

int c=0;

c=a+b;

return c;

}

调用函数的过程：

0: iconst_0 // 0压栈

1: istore_2 // 弹出int，存放于局部变量2

2: iload_0 // 把局部变量0压栈

3: iload_1 // 局部变量1压栈

4: iadd //弹出2个变量，求和，结果压栈

5: istore_2 //弹出结果，放于局部变量2

6: iload_2 //局部变量2压栈

7: ireturn //返回

a,b变量的值分别是100和98,以下是操作数栈的工作原理以及和局部变量表的关系：

00002.jpeg

帧数据区：

栈帧需要数据开支持常量池解析，正常方法返回和异常处理等

以下的例子是个递归，没有递归的出口，会出现栈溢出，并打印递归的深度。

public class TestStackDeep {

private static int count=0;

public static void recursion(long a,long b,long c){

long e=1,f=2,g=3,h=4,i=5,k=6,q=7,x=8,y=9,z=10;

count++;

System.out.println(count);

recursion(a, b, c);

}

public static void recursion(){

count++;

System.out.println(count);

recursion();

}

public static void main(String[] args) {

try {

// recursion(0L,0L,0L);

recursion();

}catch (Exception e){

System.out.println("deep of calling="+count);

e.fillInStackTrace();

}

}

}

影响栈空间使用的因素：

1.阐述列表的参数多。

2.递归的深度过深了。

-Xss256k:

deep of calling=568

递归调用了568次

-Xss512k:

deep of calling=3030

递归调用了568次

Exception in thread "main" java.lang.StackOverflowError

栈溢出，栈的空间满了。可以通过减少参数或局部变量的个数，减少栈空间的占用，达到函数多调用几次的目的。

调用recursion(a, b, c);-Xss256k：

最大深度716

调用调用recursion()，-Xss256k：

最大深度1963

可以看到在相同的栈容量下，局部变量少的函数可以支持更深的函 数调用。

二.栈上分配：

栈上分配是jvm的一个优化技术，对于那些线程私有的对象，可以将它们分配在栈上，而不是堆上。栈上分配的好处是可以在函数调用后自行销毁，而不是GC介入，从而提升了系统的性能。

栈上分配的基础是逃逸分析，逃逸分析的目的是判断对象的作用域是否有可能逃逸出函数体。

函数alloc()内的变量b是线程私有的局部变量，

public class OnStackTest {

public static void alloc(){

byte[] b=new byte[2];

b[0]=1;

}

public static void main(String[] args) {

long b=System.currentTimeMillis();

for(int i=0;i<100000000;i++){

alloc();

}

long e=System.currentTimeMillis();

System.out.println(e-b);

}

}

第一种运行方式：-server -Xmx10m -Xms10m -XX:+DoEscapeAnalysis -XX:+PrintGC

这种方式new对象在栈上分配，gc不参与回收，因为变量仅仅在栈上分配空间，降低gc的工作量，同时防止堆上的空间被占用

输出结果 5 效率很高。

第二种运行方式：-server -Xmx10m -Xms10m -XX:-DoEscapeAnalysis -XX:+PrintGC

这种方式new对象在java堆上分配，gc参与释放

输出结果：

……

[GC 3550K->478K(10240K), 0.0000977 secs]

[GC 3550K->478K(10240K), 0.0001361 secs]

[GC 3550K->478K(10240K), 0.0000963 secs]

564

GC的效率明显低于栈上分配对栈帧的销毁的效率。

小对象(一般几十个bytes)，在没有逃逸的情况下，可以直接分配在栈上

直接分配在栈上，可以自动回收，减轻GC压力

大对象或者逃逸对象无法栈上分配

逃逸分析：

下面的代码显示了一个逃逸的对象：因为代码中的User的作用域是整个Main Class，所以user对象是可以逃逸出函数体的。

public class PartionOnStack {

static class User{

private int id;

private String name;

public User(){}

}

private static User user;//在这里逃逸

public static void foo() {

user=new User();

user.id=1;

user.name="sixtrees";

}

public static void main(String[] args) {

foo();

}

}

下面的代码展示的则是一个不能逃逸的代码段。(不能逃逸的才能栈上分配)

public class PartionOnStack {

class User{

private int id;

private String name;

public User(){}

}

public void foo() {

User user=new User();

user.id=1;

user.name="sixtrees";

}

public static void main(String[] args) {

PartionOnStack pos=new PartionOnStack();

pos.foo();

}

}

总结：

*小对象(一般几十个bytes)，在没有逃逸的情况下，可以直接分配在栈上

*直接分配在栈上，可以自动回收，减轻GC压力

*大对象或者逃逸对象无法栈上分配