栈：先进后出
Java虚拟机栈的概念英文全称是Java virtual machine stacks。比如，Java中每个线程运行的时候，需要给每个线程划分一个内存空间。虚拟机栈其实是线程运行时需要的内存空间。一个线程，就需要一个栈，如果是多个线程，就需要多个虚拟机栈。
栈内由什么组成一个栈内，可以看做是由多个栈帧组成，比如，一些元素要放入栈的话，这些元素都称之为栈帧。
什么是栈贞一个栈帧对应着一次方法的调用。因为线程最终是为了要执行代码的，这些代码又是由一个个的方法组成的，所以线程运行的时候，每个方法需要的内存称之为一个栈帧。所以栈帧就是每个方法运行时需要的内存。
比如方法内的参数、局部变量啥的都需要内存，如果方法有返回值的话，
就要有返回地址，这个也是需要占用内存的。所以每个方法执行时，要
预先给他分配好内存。
比如我调用第一个方法时，他就会给第一个方法分配一个栈帧空间，并且把他压入栈内。当这个方法执行完了，就会把对应的栈帧出栈，就是释放这个方法所占用的内存。一个栈内是可以有多个栈贞的，比如调用方法1，那么这个栈帧就干入到栈里，然后这个方法1又调用了方法2，那么方法2也会产生一个新的栈帧，然后干入到栈中，方法2假设又调用了方法3，那么就会让方法3也会产生栈帧内存，放入栈内。等方法3调用结束，就会把栈帧3的内存释放掉，然后回到方法2，方法2调用结束后，他就会把方法2占用的栈帧内存释放掉并出栈，最后方法1执行完毕后也把方法1占用的栈帧内存释放并出栈。
整理为三句- 每个线程运行时所需要的内存，称为虚拟机栈。
- 每个栈由多个栈帧（frame）组成，对应着每次方法调用时所占用的内存。
- 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法。活动栈帧就是在栈的顶部的正在执行的方法。
// 演示栈帧
public class Deme {
public static void main(String[] args) throws InterruptedException {
method1();
}
private static void method1() {
method2(1,2);
}
private static int method2(int a, int b) {
int c = a + b;
return c;
}
}
先调用主方法，主方法对应一个栈帧，被放入栈内。然后主方法调用method1()，那么method1()也会有自己的内存空间，所以method1也被分配一块儿栈帧内存，并且把这个新的栈帧压入到栈内。接着method1又调用了method2，那么给method2又分配了一块儿栈帧，让这个栈帧也入栈。在method2里面，参数a和b以及局部变量c都会占用内存空间，当然调用结束还得记录返回地址，让他知道执行完method2后要到哪去。方法2执行结束后，他占用的内存，随着这个栈帧出栈被释放掉，在idea的下面Frames部分也能看出方法2的栈帧出栈了，以此类推。
问题辨析垃圾回收是否涉及栈内存？
不需要。因为栈内存无非就是一次次的方法调用所产生的栈帧内存，而栈帧内存在每一次方法调用结束后，都会被d出栈，也就是会被自动的回收掉，所以根本不需要垃圾回收来管理栈内存。
栈内存分配越大越好吗？
栈内存可以在运行代码时通过虚拟机参数指定，即“-Xss”这个参数，他是给我们栈内存指定大小，如果不指定，Linux、macOS、Solaris等系统默认每个栈的大小都是1024KB（一兆），Windows比较特殊，他是Windows的虚拟内存影响栈的大小。栈内存设置的越大，反而会让线程数变得更少，因为物理内存的大小是一定的，比如说我一个线程使用的是一个栈内存，那一个线程假如用了一兆内存，假如总共的物理内存假设有500兆，那理论上可以有五百个线程同时运行，但假如把每个线程的栈内存设置了2M内存，那么理论上只能同时运行250个线程。所以栈内存并不是划分的越大越好。把他设置大了，通常只是能够进行更多次的方法递归调用，而不会增强运行的效率，反而会影响到线程数目的变少。所以不建议设置为太大，一般采用系统默认的即可。
方法内的局部变量是否线程安全？
看一个变量是不是线程安全，要看多个线程对这个变量是共享的还是这个变量被每个线程是私有的。比如代码示例如下：
// 局部变量的线程安全问题
public class Demo {
// 多个线程同时执行此方法
static void m1() {
int x = 0;
for(int i = 0; i < 5000; i ++) {
x ++;
}
print(x);
}
}
这个方法内有局部变量x，循环5000次自增，然后打印。当多个线程同时执行这个方法时，比如有两个线程都来调这个方法，那么会不会造成最后x值的混乱呢？答案是不会。因为x是方法内的局部变量，一个线程对应一个栈，线程内每一次方法调用都会产生一个新的栈帧，比如线程1调用这个方法，那么他就会在栈1里开栈帧1，里面有局部变量x，初始值是0，接下来线程2也调用m1方法，那么会在栈2里再产生一个栈帧2，在栈帧2里也有自己的局部变量x，x的初始值也是0，相当于每个线程都有自己私有的x这个局部变量，所以他们各自加5000，互不干扰，最后每个线程内都会得出x结果是5000。所以，在这个例子里是不会有线程安全问题。
当然，如果这个变量改成static变量，结果就会大不一样了。
因为这样的话就相当于共享了。所以要考虑的问题是，如果是共享的，
就要考虑线程安全问题，不是共享的而是每个线程私有的，就算了。
再看看下面的代码示例：
public class Demo {
public static void main(String[] args) {
}
public static void m1() {
StringBuilder sb = new StringBuilder();
sb.append(1);
sb.append(2);
sb.append(3);
print(sb.toString());
}
public static void m2(StringBuilder sb) {
sb.append(1);
sb.append(2);
sb.append(3);
print(sb.toString());
}
public static StringBuilder m3() {
StringBuilder sb = new StringBuilder();
sb.append(1);
sb.append(2);
sb.append(3);
return sb;
}
}
这里有三个方法 m1 m2 m3，都做用stringbuilder做字符串的拼接 *** 作。那么这三个方法会不会存在线程安全问题呢。
m1是不会有线程安全问题的，这个跟第一个代码示例中的分析是一个道理，即在m1的sb是线程内的局部变量，可以说是每个线程私有的。
m2和m1的不同之处是sb不是方法内的局部变量，而是方法的参数，这段代码是线程不安全的，因为既然sb是作为方法的参数传递进来的，那么就意味着有可能有其他的线程访问到sb，所以这时候sb不再是线程私有的了，有可能是多个线程都能访问到他，这意味着这里的sb对多个线程是共享的。
比如，在main方法内添加如下代码示例：
StringBuilder sb = new StringBuilder();
sb.append(4);
sb.append(5);
sb.append(6);
new Thread(()->{
m2(sb);
}).start();
即在主方法里创建了sb，然后开了新的线程，新的线程里，把sb传给了m2方法，那么主线程和新的线程里都在修改sb，所以两个线程在使用者同一个sb对象，这样的话在这个场景下不再是线程私有的了，而是多个线程共享了同一个对象，所以不再是线程安全的了。所以这时候，不能用stringbuilder了，应该改成stringbuffer。
那么m3是不是线程安全呢？答案也是不行。因为，虽然sb是方法内的局部变量，但是他把他当做返回结果，返回了，那就意味着其他的线程有可能会拿到这个引用，去并发的修改他，所以也会造成线程安全的问题。
要想判断一个变量是不是线程安全的，不仅要看他是不是方法内的局部
变量，还要看他是否逃离了这个方法的作用范围，如果像m3那样逃离了
方法作用范围，那么他就有可能会被别的线程访问到了，就不再是线程
安全的了。（当然了，基本类型除外。）
什么情况下会导致栈内存溢出？
栈帧过多导致栈内存溢出。
比如栈的大小是固定的，然后方法1调用，栈内就进来栈帧1，然后方法1调用方法2，就会有栈帧2干入，就这样以此类推不断的调用到n，即一直入栈，没有出栈，直到某一次调用，这个栈帧的总内存超过了栈的内存，放不下了，无法分配新的空间了，这样就会导致栈内存溢出。
在方法的递归调用时，可能会出现这种情况，如果在方法递归调用里没有设置正确的结束条件，那么就会导致自己调用自己，自己再调用自己…不断调用，每次调用都会产生一个栈帧，那么即使你的栈内存再大，也终有会用完的一天，所以会导致栈内存溢出。
栈帧过大导致栈内存溢出。
比如，一个栈帧的大小直接超过栈内存，这种情况不太容易出现，因为方法内部的参数之类的占用内存都不会很大，而默认的栈大小都一兆左右，所以再多的局部变量也很难耗尽栈内存。所以一般都是上面的第一种情况。
栈内存溢出的场景案例1：
public class Demo {
private static int count;
public static void main(String[] args) {
try{
method1();
}catch(Throwable e) {
e.printStackTrace();
print(count);
}
}
private static void method1() {
count++;
method1();
}
}
这个代码中，method1自己调用自己，但没设置递归终止条件，这样的话，每调用一次，就会产生新的栈帧，最终会耗尽栈内存。
最后报错是：java.lang.StackOverflowError，即栈内存溢出了。假如，这里count输出几万次，说明递归了几万次，如果把-Xss值（栈内存）设置为256k，这么小的话，count就会变小多了。
栈内存溢出的场景案例2：
可能有人会说，自己肯定会设置结束条件，但有时候并不是因为代码而导致栈内存溢出，而是也许会因第三方的库也会导致栈内存溢出异常抛出。
// json数据转换，把Java对象转换成json的字符串数据
public class Demo {
public static void main(String[] agrs) throws JsonProcessingException {
Dept d = new Dept();
d.setName("market");
Emp e1 = new Emp();
e1.setName("zhang");
e1.setDept(d);
Emp e2 = new Emp();
e2.setName("li");
e2.setDept(d);
d.setEmps(Arrays.asList(e1,e2));
ObjectMapper mapper = new ObjectMapper();
print(mapper.writeValueAsString(d));
}
}
class Emp {
private String name;
private Dept dept;
... set get
}
class Dept {
private String name;
private List<Emp> emps;
... set get
}
在这里，要转换的对象是Dept类（部门）和Emp类（员工），Dept中有Emp的集合，因为一个部门有多个员工。Emp里面也有Dept，属于哪个部门。
在main方法中，先创建了部门对象d，然后创建了两个员工e1 e2，两个员工都设置了部门为d，然后部门d对象设置了两个员工的list。然后创建ObjectMapper（转换Java对象到json字符串的类），然后输出转换结果。
运行后，就会出现Infinite recursion（StackOverflowError）错误，无限递归，出现了StackOverflowError，这是为何呢？
这里使用的转换类不是我们自己写的，是第三方的，为何会出现栈内存溢出的错误呢？这是因为转换时给d设置emps时，这emps里面也有dept，然后dept里面又有emps…就这样出现死递归了。所以，有时候，并不是因为写的代码而出现栈内存溢出，这里是因为两个类循环引用问题导致json解析时会出现栈内存溢出错误。
可以在Emp类的private Dept dept;属性上面加@JsonIgnore，意思是，转换员工的时候，遇到这个部门属性，就不转了，这样的话，双向循环的问题解决。即用部门去关联员工，员工这边不再关联部门了。@JsonIgnore就是转换是要忽略这个属性的转换。改了后输出如下：
{“name”:“Market”,“emps”:[{“name”:“zhang”},{“name”:“li”}]}
即在emps里面的员工类中不再出现dept属性了，这样就避免了栈内存错误，所以编程时要注意这方面导致栈内存溢出的问题。
class Emp {
private String name;
@JsonIgnore
private Dept dept;
... set get
}
线程和虚拟机栈是息息相关的，所以线程运行诊断也可能重要。
案例1：CPU占用过多
比如，在Linux中，在后台运行（nohup）某个Java文件，让其进程占用CPU的99.2%（一直变化，而居高不下），但假设不知道具体哪个线程导致的。
nohup java com.asd.Demo &
运行以后，可以用top命令可以检测到后台的这些进程对CPU的使用对内存的占用情况，用top命令实时监测一下：
top
可以看到，确实有个Java代码，占了CPU的99.3%，其他程序都0.几%，就他不断的在使用者CPU。
这是很危险的信号，那么怎么去进一步查询他的问题呢？用top命令时，至少能判断出有问题的进程编号（PID），但top命令只能定位到进程，他无法定位到这个进程中是哪个线程导致CPU占用居高不下，所以先把top命令停掉。（此处用top的作用可能是可以定位哪个进程对cpu的占用过高）
可以用另外一个命令ps，他可以去查看线程对CPU的占用情况。H是打印进程数，还有进程里所有线程信息都展示出来。-eo规定输出哪些感兴趣的内容，比如感兴趣的是进程ID的话，就写pid，还对线程ID感兴趣的话，加tid，如果还对他们对CPU的占用感兴趣，可以加%cpu。这样的话就能看到所有线程的这三项（pid,tid,%cpu）指标了（此处是用ps命令进一步定位是哪个线程引起的CPU占用过高）。
ps H -eo pid,tid,%cpu
执行后出来一堆，但其中也能看到有个项目比如如下：
...
32655 32665 99.5
...
即32655这个进程中，32665这个线程，占用了CPU的99.5%。
当然，如果一堆东西太多显得麻烦，可以加筛选条件（因为进程ID我们已知，所以用进程ID筛选），这样就能过滤掉其他进程的信息：
ps H -eo pid,tid,%cpu | grep 32655
接下来，用JDK提供的工具来看看到底是哪个线程出现了问题，可以用jstack，后面跟上进程ID即可。
jstack 32655
执行后，他就会列出这个进程中所有的Java线程。里面有比如“Attack Listener”之类的一堆Java虚拟机定义的相关线程，还有几个用户定义的线程，比如“thread2”、“thread1”之类的（仅限此处的例子），因为Java虚拟机自己的线程名字都是固定的。那么在这么多的线程里如何排查哪个线程有问题呢？刚才，已经用ps命令定位到了一个32655的线程是有问题的，所以可以用这个线程编号在jstack输出的线程信息中找到他，但ps命令出来的线程编号是十进制的，但用jstack输出而来的编号是十六进制的，所以要先换算把十进制的编号改为十六进制的（可以在网上计算器换算，换算后16进制是7F99）。然后在此处例子中可以看到“thread1”是7F99，所以，就能发现问题应该就在这里，比如如下：。
...
"thread1" #8 prio=5 os_prio=0 tid=0x00007fc26c10c000 nid=0x7f99 runnable [0x00007fc25b2e8000]
java.lang.Thread.State: RUNNABLE
at com.asd.Demo.lambda()Demo.java:8$$
at com.asd.DemoLambda(/834600351.run)Unkonwn Source(
at java.lang.Thread.run)Thread.java:745..
案例2：程序运行很长时间没有结果.
可以看到，他的线程状态是RUNNABLE，说明他一直在运行着，就是它占用了CPU过多的时间片。可以看到出现问题的代码行数是8行，然后打开这个类（Demo.java），在此处例子中，8行是while死循环（仅限此处例子），就是因为它而占用了CPU的过多时间片。
当然，实际上，还会有其他更多情况可能会出现此种情况，不过，在这里重要的是，定位分析的方法都是一样的。
.
比如，有Java程序，运行了很长时间，依然没有算出你想要的那个结果。这次运行另外一个Java程序：
nohup java com.asdjstack 32752
Demo &
运行后，发现本来我想输出什么结果，但过了很长时间依然不输出。有可能是你的多个线程发生了死锁才导致等了很久都等不到你要的结果。那如何排查这种线程死锁的问题呢？（此程序运行的进程ID是32752）可以用刚才的jstack命令。
..
执行后，像刚才一样，可以看到这个进程中所有的线程信息，比如JVM的一些线程，还有用户线程之类的。用jstack的时候，可以去看看最后的输出内容，此例子中，最后输出内容中有“Found one Java-level deadlock:”这种文句，deadlock就是死锁的意思。比如如下：
==.
Found one Java-level deadlock:
==========================="Thread-1"
(
waiting to lock monitor 0x00007fba04003778 )object 0x000000000f0a3fc8, a com.asd.Awhich,
"Thread-0" is held by "Thread-0"
(
waiting to lock monitor 0x00007fba040062c8 )object 0x000000000f074f30, a com.asd.Bwhich,
"Thread-1" is held by ..
...
这说明用户自定义的"Thread-1"，"Thread-0"这两个线程可能有问题。在上段文字的下面，也会列出详细的错误信息，比如如下：
(.)接着上文for
Java stack information == the threads listed above:
=================================================="Thread-1"
:
at com.asd.Demo.lambda()Demo.java:29<
- waiting to lock 80x000000000f0a73fc(> )a com.asd.A<
- locked 00x00000000f0a74f3(> )a com.asd.B$$
at com.asd.DemoLambda(/1418481495.run)Unknown Source(
at java.lang.Thread.run)Thread.java:745"Thread-0"
:(
at com.asd.Demo.lambda)<Demo.java:210
- waiting to lock (0x000000000f0a74f3)> <a com.asd.B8
- locked (0x00000000f0a73fc)> $$a com.asd.A
at com.asd.Demo(Lambda)/834600351.run(Unknown Source)
at java.lang.Thread.run1Thread.java:745..
Found ( deadlock.
).
这说明，Demo.java的29行代码有问题，以及21行，这两行代码中发生了死锁。定位到了后，可以去具体的代码中，看看是不是因为编码有误导致的错误。（实际情况中也是这样先定位然后去排查问题）至于问题代码解析部分这里省略，因为这里主要说的是排查的方法。
本地方法栈Java虚拟机调用一些本地方法时，需要给本地方法提供的内存空间。本地方法（native method）是指不是由Java编写的代码，因为Java代码是有一定的限制的，他有的时候不能够去直接跟 *** 作系统底层打交道，所以就需要一些这种用C或C++语言编写的本地方法来真正与 *** 作系统底层的API打交道，所以Java代码可以间接的去通过本地方法来调用到底层的一些功能，这些本地方法运行的时候他所使用的内存就是本地方法栈。
那这样的本地方法多不多呢，答案是非常的多。不管是一些Java的基础类库里，还是在执行引擎里，他们都会去调用这些本地方法。
在Object这个类中也有很多本地方法的调用，比如clone方法就是
native方法，可以看到这些native方法没有方法实现，因为实现是C
或C++做的，Java只是间接的用这种方式去调用真正的C或C++的实现。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）