-
Notifications
You must be signed in to change notification settings - Fork 2.3k
Expand file tree
/
Copy pathjvm.md
More file actions
2515 lines (1522 loc) · 141 KB
/
jvm.md
File metadata and controls
2515 lines (1522 loc) · 141 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
---
title: JVM面试题,54道Java虚拟机八股文(2.3万字115张手绘图),面渣逆袭必看👍
shortTitle: 面渣逆袭-JVM
author: 三分恶
date: 2026-03-29
category:
- 面渣逆袭
tag:
- 面渣逆袭
description: 下载次数超 1 万次,2.3 万字 115 张手绘图,详解 54 道 Java 虚拟机面试高频题(让天下没有难背的八股),面渣背会这些 JVM 八股文,这次吊打面试官,我觉得稳了(手动 dog)。
head:
- - meta
- name: keywords
content: Java,Java虚拟机,JVM,Java面试题,JVM面试题,java虚拟机面试题,八股文,java
---

## 前言
2.3 万字 115 张手绘图,详解 54 道 Java 虚拟机面试高频题(让天下没有难背的八股),面渣背会这些 JVM 八股文,这次吊打面试官,我觉得稳了(手动 dog)。整理:沉默王二,戳[转载链接](https://mp.weixin.qq.com/s/bHhqhl8mH3OAPt3EkaVc8Q),作者:三分恶,戳[原文链接](https://mp.weixin.qq.com/s/XYsEJyIo46jXhHE1sOR_0Q)。
亮白版本更适合拿出来打印,这也是很多学生党喜欢的方式,打印出来背诵的效率会更高。

2024 年 12 月 30 日开始着手第二版更新。
- 对于高频题,会标注在《[Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)》中出现的位置,哪家公司,原题是什么,并且会加🌟,目录一目了然;如果你想节省时间的话,可以优先背诵这些题目,尽快做到知彼知己,百战不殆。
- 区分八股精华回答版本和原理底层解释,让大家知其然知其所以然,同时又能做到面试时的高效回答。
- 结合项目([技术派](https://javabetter.cn/zhishixingqiu/paicoding.html)、[pmhub](https://javabetter.cn/zhishixingqiu/pmhub.html))来组织语言,让面试官最大程度感受到你的诚意,而不是机械化的背诵。
- 修复第一版中出现的问题,包括球友们的私信反馈,网站留言区的评论,以及 [GitHub 仓库](https://github.com/itwanger/toBeBetterJavaer/issues)中的 issue,让这份面试指南更加完善。
- 增加[二哥编程星球](https://javabetter.cn/zhishixingqiu/)的球友们拿到的一些 offer,对面渣逆袭的感谢,以及对简历修改的一些认可,以此来激励大家,给大家更多信心。
- 优化排版,增加手绘图,重新组织答案,使其更加口语化,从而更贴近面试官的预期。

由于 PDF 没办法自我更新,所以需要最新版的小伙伴,可以微信搜【**沉默王二**】,或者扫描/长按识别下面的二维码,关注二哥的公众号,回复【**222**】即可拉取最新版本。
<div style="text-align: center; margin: 20px 0;">
<img src="https://cdn.paicoding.com/tobebetterjavaer/images/gongzhonghao.png" alt="微信扫码或者长按识别,或者微信搜索“沉默王二”" style="max-width: 100%; height: auto; border-radius: 10px;" />
</div>
当然了,请允许我的一点点私心,那就是星球的 PDF 版本会比公众号早一个月时间,毕竟星球用户都付费过了,我有必要让他们先享受到一点点福利。相信大家也都能理解,毕竟在线版是免费的,CDN、服务器、域名、OSS 等等都是需要成本的。
更别说我付出的时间和精力了,大家觉得有帮助还请给个口碑,让你身边的同事、同学都能受益到。

我把二哥的 Java 进阶之路、JVM 进阶之路、并发编程进阶之路,以及所有面渣逆袭的版本都放进来了,涵盖 Java基础、Java集合、Java并发、JVM、Spring、MyBatis、计算机网络、操作系统、MySQL、Redis、RocketMQ、分布式、微服务、设计模式、Linux 等 16 个大的主题,共有 40 多万字,2000+张手绘图,可以说是诚意满满。
展示一下暗黑版本的 PDF 吧,排版清晰,字体优雅,更加适合夜服,晚上看会更舒服一点。

## 一、引言
### 1.什么是 JVM?
JVM,也就是 Java 虚拟机,它是 Java 实现跨平台的基石。
程序运行之前,需要先通过编译器将 Java 源代码文件编译成 Java 字节码文件;
程序运行时,JVM 会对字节码文件进行逐行解释,翻译成机器码指令,并交给对应的操作系统去执行。

这样就实现了 Java 一次编译,处处运行的特性。
#### 如果我们要执行hello world,那虚拟机干了什么呢?谁把字节码翻译成机器码,操作时机是什么?Java虚拟机是一个执行单元吗?
当我们写好一个 HelloWorld 程序,编译成 .class 文件后,执行 `java HelloWorld` 这条命令时,操作系统会创建一个 JVM 进程,JVM 进程启动起来后,会先初始化运行环境,包括创建类加载器、初始化内存空间、启动垃圾回收线程等等。
接下来,JVM 的类加载器会去找 HelloWorld.class 这个文件,读取它的字节码内容。
JVM 的执行引擎会将这些字节码翻译成机器码,有两种方式:
- 第一种是解释执行。JVM 的解释器会逐条读取字节码指令,然后把它翻译成机器码执行。这个过程是动态的,每次执行都要翻译一遍。所以解释执行的速度相对较慢。
- 第二种是即时编译。JVM 里有一个 JIT 编译器,他发现某段代码被频繁执行(比如循环里的代码或者热点方法)时,JIT 编译器就会把这段字节码直接编译成本地机器码并缓存到 codeCache 中,下次执行的时候不用再一行一行的解释,而是直接执行缓存后的机器码,执行效率会大幅提高。
至于执行的时机,解释器的执行是立即的,当 JVM 启动后,就开始解释执行字节码了。JIT 编译器的执行时机是延后的,它需要先监控哪些代码是热点代码(通常需要执行数千次或者数万次),然后才会启动编译。
操作系统层面,JVM 进程是一个执行单元,由操作系统调度执行。
#### 说说 JVM 的其他特性?
①、JVM 可以自动管理内存,通过垃圾回收器回收不再使用的对象并释放内存空间。
②、JVM 包含一个即时编译器 JIT,它可以在运行时将热点代码缓存到 codeCache 中,下次执行的时候不用再一行一行的解释,而是直接执行缓存后的机器码,执行效率会大幅提高。

③、任何可以通过 Java 编译的语言,比如说 Groovy、Kotlin、Scala 等,都可以在 JVM 上运行。

#### 为什么要学习 JVM?
学习 JVM 可以帮助我们开发者更好地优化程序性能、避免内存问题。
比如说了解 JVM 的内存模型和垃圾回收机制,可以帮助我们更合理地配置内存、减少 GC 停顿。
比如说掌握 JVM 的类加载机制可以帮助我们排查类加载冲突或异常。
再比如说,JVM 还提供了很多调试和监控工具,可以帮助我们分析内存和线程的使用情况,从而解决内存溢出内存泄露等问题。
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的京东同学 10 后端实习一面的原题:有了解 JVM 吗
> 2. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的字节跳动同学 20 测开一面的原题:了解过 JVM 么?讲一下 JVM 的特性
memo:2025 年 11 月 6 日修改至此,[今天有球友](https://javabetter.cn/zhishixingqiu/)提问说拿到了京东测开的 offer,60 万总包;还有华为的 14a offer,真的恭喜他,太强了呀。

### 2.说说 JVM 的组织架构(补充)
> 增补于 2024 年 03 月 08 日。
推荐阅读:[大白话带你认识 JVM](https://javabetter.cn/jvm/what-is-jvm.html)
JVM 大致可以划分为三个部分:类加载器、运行时数据区和执行引擎。

① 类加载器,负责从文件系统、网络或其他来源加载 Class 文件,将 Class 文件中的二进制数据读入到内存当中。
② 运行时数据区,JVM 在执行 Java 程序时,需要在内存中分配空间来处理各种数据,这些内存区域按照 Java 虚拟机规范可以划分为方法区、堆、虚拟机栈、程序计数器和本地方法栈。
③ 执行引擎,也是 JVM 的心脏,负责执行字节码。它包括一个虚拟处理器、即时编译器 JIT 和垃圾回收器。
#### JVM 是个什么东西?
JVM 本质上就是一个进程。当我们执行 `java -jar application.jar` 命令时,操作系统会创建一个名为 JVM 的进程。这个进程在内存里运行着一个虚拟机,这个虚拟机有自己的指令集、内存模型、执行引擎等等。
#### Java虚拟机和操作系统的关系到底什么,假如我是个完全不懂技术的人,举例说明让我明白
想象操作系统是一个大剧院。这个剧院有舞台、灯光、音响、观众座位等各种资源。剧院的管理员负责分配这些资源,决定谁在什么时候用哪个舞台。
现在,一个话剧团想在这个剧院里演一场就在河南。话剧团就向剧院管理员说:"我需要租用你的舞台、灯光、音响,从下午 2 点到 5 点。"剧院管理员就给他们分配了一个舞台和相关资源。

操作系统是底层,它直接控制硬件资源,比如 CPU、内存、磁盘、网络等。操作系统的工作就是把这些硬件资源分配给各个应用程序使用。
JVM 是运行在操作系统上的一个应用程序。JVM 本身是一个进程,也就是说,从操作系统的角度看,JVM 就是一个普通的应用程序,并没有什么特别的。操作系统不知道也不关心 JVM 里面运行的是什么,它只是按照进程管理的规则来管理 JVM 这个进程。
### 一个操作系统有两个Java程序的话,有几个虚拟机?有没有单独的JVM进程存在?启动一个hello world编译的时候,有几个进程
1、每一个 Java 程序都需要一个独立的 JVM 进程来运行,两个 Java 程序就需要两个 JVM。这两个 JVM 进程是完全独立的,互不干扰。
2、JVM 不存在什么公共的、被所有 Java 程序共享的进程。每一个 Java 程序都必须启动自己的 JVM 进程。
3、如果只是编译,不运行,至少有两个进程。一个是 javac 的编译器进程。当执行 `javac HelloWorld.java` 时,操作系统会创建一个 javac 进程,这个进程会读取 .java 源文件,生成 .class 字节码文件。完成后 javac 进程就退出了。另一个是当前的 shell 进程,运行 javac 进程的终端,这是一直存在的。
#### JVM什么时候启动 比如执行一条Java命令的时候对应一个进程,然后这个JVM虚拟机到底是不是在这个进程里面,还是说要先启动一个JVM虚拟机的进程
当执行 `java HelloWorld` 这条命令的时候,操作系统就会创建 JVM 进程。没有"先启动 JVM"然后"再运行程序"这种操作。而是一步到位:操作系统启动了 JVM 进程,JVM 进程同时运行 Java 程序。
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的腾讯 Java 后端实习一面原题:说说 JVM 的组织架构
> 2. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的得物面经同学 9 面试题目原题:JVM的架构,具体阐述一下各个部分的功能?
memo:2025 年 11 月 04 日修改至此,[今天有球友](https://javabetter.cn/zhishixingqiu/)私信说美团开奖了,白菜,但今年美团整体开的都是这个价,24k 左右,去年其实也差不多这个价,好在美团业务稳定,整体氛围还可以。

## 二、内存管理
### 3.🌟能说一下 JVM 的内存区域吗?
推荐阅读:[深入理解 JVM 的运行时数据区](https://javabetter.cn/jvm/neicun-jiegou.html)
按照 Java 虚拟机规范,JVM 的内存区域可以细分为`程序计数器`、`虚拟机栈`、`本地方法栈`、`堆`和`方法区`。

其中`方法区`和`堆`是线程共享的,`虚拟机栈`、`本地方法栈`和`程序计数器`是线程私有的。
#### 介绍一下程序计数器?
程序计数器也被称为 PC 寄存器,是一块较小的内存空间。它可以看作是当前线程所执行的字节码行号指示器。
#### 介绍一下 Java 虚拟机栈?
Java 虚拟机栈的生命周期与线程相同。
当线程执行一个方法时,会创建一个对应的[栈帧](https://javabetter.cn/jvm/stack-frame.html),用于存储局部变量表、操作数栈、动态链接、方法出口等信息,然后栈帧会被压入虚拟机栈中。当方法执行完毕后,栈帧会从虚拟机栈中移除。

#### 一个什么都没有的空方法,空的参数都没有,那局部变量表里有没有变量?
对于[静态方法](https://javabetter.cn/oo/static.html),由于不需要访问实例对象 this,因此在局部变量表中不会有任何变量。
对于非静态方法,即使是一个完全空的方法,局部变量表中也会有一个用于存储 this 引用的变量。this 引用指向当前实例对象,在方法调用时被隐式传入。
详细解释一下:
比如说有这样一段代码:
```java
public class VarDemo1 {
public void emptyMethod() {
// 什么都没有
}
public static void staticEmptyMethod() {
// 什么都没有
}
}
```
用 `javap -v VarDemo1` 命令查看编译后的字节码,就可以在 emptyMethod 中看到这样的内容:

这里的 `locals=1` 表示局部变量表有一个变量,即 this,Slot 0 位置存储了 this 引用。
而在静态方法 staticEmptyMethod 中,你会看到这样的内容:

这里的 locals=0 表示局部变量表为空,因为静态方法属于类级别方法,不需要 this 引用,也就没有局部变量。
#### 介绍一下本地方法栈?
本地方法栈与虚拟机栈相似,区别在于虚拟机栈是为 JVM 执行 Java 编写的方法服务的,而本地方法栈是为 Java 调用[本地 native 方法](https://javabetter.cn/oo/native-method.html)服务的,通常由 C/C++ 编写。
在本地方法栈中,主要存放了 native 方法的局部变量、动态链接和方法出口等信息。当一个 Java 程序调用一个 native 方法时,JVM 会切换到本地方法栈来执行这个方法。
#### 介绍一下本地方法栈的运行场景?
当 Java 应用需要与操作系统底层或硬件交互时,通常会用到本地方法栈。
比如调用操作系统的特定功能,如内存管理、文件操作、系统时间、系统调用等。
详细说明一下:
比如说获取系统时间的 `System.currentTimeMillis()` 方法就是调用本地方法,来获取操作系统当前时间的。

再比如 JVM 自身的一些底层功能也需要通过本地方法来实现。像 Object 类中的 `hashCode()` 方法、`clone()` 方法等。

#### native 方法解释一下?
推荐阅读:[手把手教你用 C语言实现 Java native 本地方法](https://javabetter.cn/oo/native-method.html)
native 方法是在 Java 中通过 [native 关键字](https://javabetter.cn/basic-extra-meal/48-keywords.html)声明的,用于调用非 Java 语言,如 C/C++ 编写的代码。Java 可以通过 JNI,也就是 Java Native Interface 与底层系统、硬件设备、或者本地库进行交互。
#### 介绍一下 Java 堆?
堆是 JVM 中最大的一块内存区域,被所有线程共享,在 JVM 启动时创建,主要用来存储 new 出来的对象。

Java 中“几乎”所有的对象都会在堆中分配,堆也是[垃圾收集器](https://javabetter.cn/jvm/gc-collector.html)管理的目标区域。
从内存回收的角度来看,由于垃圾收集器大部分都是基于分代收集理论设计的,所以堆又被细分为`新生代`、`老年代`、`Eden空间`、`From Survivor空间`、`To Survivor空间`等。

随着 [JIT 编译器](https://javabetter.cn/jvm/jit.html)的发展和逃逸技术的逐渐成熟,“所有的对象都会分配到堆上”就不再那么绝对了。
从 JDK 7 开始,JVM 默认开启了逃逸分析,意味着如果某些方法中的对象引用没有被返回或者没有在方法体外使用,也就是未逃逸出去,那么对象可以直接在栈上分配内存。
#### 堆和栈的区别是什么?
堆属于线程共享的内存区域,几乎所有 new 出来的对象都会堆上分配,生命周期不由单个方法调用所决定,可以在方法调用结束后继续存在,直到不再被任何变量引用,最后被垃圾收集器回收。
栈属于线程私有的内存区域,主要存储局部变量、方法参数、对象引用等,通常随着方法调用的结束而自动释放,不需要垃圾收集器处理。
#### 介绍一下方法区?
方法区并不真实存在,属于 Java 虚拟机规范中的一个逻辑概念,用于存储已被 JVM 加载的类信息、常量、静态变量、即时编译器编译后的代码缓存等。
在 HotSpot 虚拟机中,方法区的实现称为永久代 PermGen,但在 Java 8 及之后的版本中,已经被元空间 Metaspace 所替代。
#### 变量存在堆栈的什么位置?
对于局部变量,它存储在当前方法栈帧中的局部变量表中。当方法执行完毕,栈帧被回收,局部变量也会被释放。
```java
public void method() {
int localVar = 100; // 局部变量,存储在栈帧中的局部变量表里
}
```
对于静态变量来说,它存储在 Java 虚拟机规范中的方法区中,在 Java 7 中是永久带,在 Java8 及以后 是元空间。
```java
public class StaticVarDemo {
public static int staticVar = 100; // 静态变量,存储在方法区中
}
```
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的京东同学 10 后端实习一面的原题:堆和栈的区别是什么
> 2. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的比亚迪面经同学 3 Java 技术一面面试原题:介绍一下 JVM 运行时数据区
> 3. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的字节跳动面经同学 1 Java 后端技术一面面试原题:讲一下 JVM 内存结构?
> 4. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的京东面经同学 1 Java 技术一面面试原题:说说 JVM 运行时数据区
> 5. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的美团面经同学 2 Java 后端技术一面面试原题:JVM 内存结构了解吗?
> 6. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的快手面经同学 1 部门主站技术部面试原题:请说一下 Java 的内存区域,程序计数器等?
> 7. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的字节跳动面经同学 8 Java 后端实习一面面试原题:jvm 内存分布,有垃圾回收的是哪些地方
> 8. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的得物面经同学 8 一面面试原题:说一说 jvm 内存区域
> 9. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的美团面经同学 3 Java 后端技术一面面试原题:jmm 内存模型 栈 方法区存放的是什么
> 10. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的收钱吧面经同学 1 Java 后端一面面试原题:你提到了栈帧,那局部变量表除了栈帧还有什么?一个什么都没有的空方法,完全空的参数什么都没有,那局部变量表里有没有变量?
> 11. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的招银网络科技面经同学 9 Java 后端技术一面面试原题:Java堆内存和栈内存的区别
> 12. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的 OPPO 面经同学 1 面试原题:说一下JVM内存模型
> 13. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的深信服面经同学 3 Java 后端线下一面面试原题:JVM变量存在堆栈的位置?
> 14. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的TP联洲同学 5 Java 后端一面的原题:Jvm内存区域,本地方法栈的运行场景,Native方法解释一下
> 15. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的字节跳动同学 17 后端技术面试原题:jvm结构 运行时数据区有什么结构 堆存什么
> 16. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的腾讯面经同学 29 Java 后端一面原题:new一个对象存放在哪里?(运行时数据区),局部变量存在JVM哪里
### 4.说一下 JDK 1.6、1.7、1.8 内存区域的变化?
JDK 1.6 使用永久代来实现方法区:

JDK 1.7 时仍然是永久带,但发生了一些细微变化,比如将字符串常量池、静态变量存放到了堆上。

在 JDK 1.8 时,直接在内存中划出了一块区域,叫**元空间**,来取代之前放在 JVM 内存中的永久代,并将运行时常量池、类常量池都移动到了元空间。

### 5.为什么使用元空间替代永久代?
客观上,永久代会导致 Java 应用程序更容易出现内存溢出的问题,因为它要受到 JVM 内存大小的限制。
HotSpot 虚拟机的永久代大小可以通过 `-XX:MaxPermSize` 参数来设置,32 位机器默认的大小为 64M,64 位的机器则为 85M。
而 J9 和 JRockit 虚拟机就不存在这种限制,只要没有触碰到进程可用的内存上限,例如 32 位系统中的 4GB 限制,就不会出问题。
主观上,当 Oracle 收购 BEA 获得了 JRockit 的所有权后,就准备把 JRockit 中的优秀功能移植到 HotSpot 中。
如 Java Mission Control 管理工具。
但因为两个虚拟机对方法区实现有差异,导致这项工作遇到了很多阻力。
考虑到 HotSpot 虚拟机未来的发展,JDK 6 的时候,开发团队就打算放弃永久代了。
JDK 7 的时候,前进了一小步,把原本放在永久代的字符串常量池、静态变量等移动到了堆中。
JDK 8 就终于完成了这项移出工作,这样的好处就是,元空间的大小不再受到 JVM 内存的限制,而是可以像 J9 和 JRockit 那样,只要系统内存足够,就可以一直用。
### 6.🌟对象创建的过程了解吗?
当我们使用 new 关键字创建一个对象时,JVM 首先会检查 new 指令的参数是否能在常量池中定位到类的符号引用,然后检查这个符号引用代表的类是否已被加载、解析和初始化。如果没有,就先执行类加载。

如果已经加载,JVM 会为对象分配内存完成初始化,比如数值类型的成员变量初始值是 0,布尔类型是 false,对象类型是 null。
接下来会设置对象头,里面包含了对象是哪个类的实例、对象的哈希码、对象的 GC 分代年龄等信息。
最后,JVM 会执行构造方法 `<init>` 完成赋值操作,将成员变量赋值为预期的值,比如 `int age = 18`,这样一个对象就创建完成了。
#### 对象的销毁过程了解吗?
当对象不再被任何引用指向时,就会变成垃圾。垃圾收集器会通过可达性分析算法判断对象是否存活,如果对象不可达,就会被回收。
垃圾收集器通过标记清除、标记复制、标记整理等算法来回收内存,将对象占用的内存空间释放出来。
可以通过 `java -XX:+PrintCommandLineFlags -version` 和 `java -XX:+PrintGCDetails -version` 命令查看 JVM 的 GC 收集器。

可以看到,我本机安装的 JDK 8 默认使用的是 `Parallel Scavenge + Parallel Old`。
不同参数代表对应的垃圾收集器表单:
新生代| 老年代| JVM参数
---|---|---|
Serial| Serial| -XX:+UseSerialGC
Parallel Scavenge| Serial| -XX:+UseParallelGC -XX:-UseParallelOldGC
Parallel Scavenge| Parallel Old| -XX:+UseParallelGC -XX:+UseParallelOldGC
Parallel New| CMS| -XX:+UseParNewGC -XX:+UseConcMarkSweepGC
G1|| -XX:+UseG1GC
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的比亚迪面经同学 3 Java 技术一面面试原题:对象创建到销毁的流程
> 2. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的美团面经同学 2 Java 后端技术一面面试原题:说说创建对象的流程?
> 3. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的携程面经同学 1 Java 后端技术一面面试原题:对象创建到销毁,内存如何分配的,(类加载和对象创建过程,CMS,G1 内存清理和分配)
memo:2025 年 8 月 13 日修改到此,[就像球友说的](https://javabetter.cn/zhishixingqiu/),帮大家拿下暑期实习,也会帮大家拿下秋招。

### 7.堆内存是如何分配的?
在堆中为对象分配内存时,主要使用两种策略:指针碰撞和空闲列表。

指针碰撞适用于管理简单、碎片化较少的内存区域,如年轻代;而空闲列表适用于内存碎片化较严重或对象大小差异较大的场景如老年代。
#### 什么是指针碰撞?
假设堆内存是一个连续的空间,分为两个部分,一部分是已经被使用的内存,另一部分是未被使用的内存。
在分配内存时,Java 虚拟机会维护一个指针,指向下一个可用的内存地址,每次分配内存时,只需要将指针向后移动一段距离,如果没有发生碰撞,就将这段内存分配给对象实例。
#### 什么是空闲列表?
JVM 维护一个列表,记录堆中所有未占用的内存块,每个内存块都记录有大小和地址信息。
当有新的对象请求内存时,JVM 会遍历空闲列表,寻找足够大的空间来存放新对象。
分配后,如果选中的内存块未被完全利用,剩余的部分会作为一个新的内存块加入到空闲列表中。
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的携程面经同学 1 Java 后端技术一面面试原题:对象创建到销毁,内存如何分配的,(类加载和对象创建过程,CMS,G1 内存清理和分配)
memo:2025 年 1 月 10 日修改到此
### 8.new 对象时,堆会发生抢占吗?
会。

new 对象时,指针会向右移动一个对象大小的距离,假如一个线程 A 正在给字符串对象 s 分配内存,另外一个线程 B 同时为 ArrayList 对象 l 分配内存,两个线程就发生了抢占。
#### JVM 怎么解决堆内存分配的竞争问题?
为了解决堆内存分配的竞争问题,JVM 为每个线程保留了一小块内存空间,被称为 TLAB,也就是线程本地分配缓冲区,用于存放该线程分配的对象。

当线程需要分配对象时,直接从 TLAB 中分配。只有当 TLAB 用尽或对象太大需要直接在堆中分配时,才会使用全局分配指针。
这里简单测试一下 TLAB。
可以通过 `java -XX:+PrintFlagsFinal -version | grep TLAB` 命令查看当前 JVM 是否开启了 TLAB。

如果开启了 TLAB,会看到类似以下的输出,其中 bool UseTLAB 的值为 true。
我们编写一个简单的测试类,创建大量对象并强制触发垃圾回收,查看 TLAB 的使用情况。
```java
class TLABDemo {
public static void main(String[] args) {
for (int i = 0; i < 10_000_000; i++) {
allocate(); // 创建大量对象
}
System.gc(); // 强制触发垃圾回收
}
private static void allocate() {
// 小对象分配,通常会使用 TLAB
byte[] bytes = new byte[64];
}
}
```
在 VM 参数中添加 `-XX:+UseTLAB -XX:+PrintTLAB -XX:+PrintGCDetails -XX:+PrintGCDateStamps`,运行后可以看到这样的内容:

- waste:未使用的 TLAB 空间。
- alloc:分配到 TLAB 的空间。
- refills:TLAB 被重新填充的次数。
可以看到,当前线程的 TLAB 目标大小为 10,496 KB(`desired_size: 10496KB`);未发生慢分配(`slow allocs: 0`);分配效率直接拉满(`alloc: 1.00000 52494KB`)。
当使用 `-XX:-UseTLAB -XX:+PrintGCDetails` 关闭 TLAB 时,会看到类似以下的输出:

直接出现了两次 GC,因为没有 TLAB,Eden 区更快被填满,导致年轻代 GC。年轻代 GC 频繁触发,一部分长生命周期对象被晋升到老年代,间接导致老年代 GC 触发。
### 9.🌟能说一下对象的内存布局吗?
好的。
对象的内存布局是由 Java 虚拟机规范定义的,但具体的实现细节各有不同,如 HotSpot 和 OpenJ9 就不一样。
就拿我们常用的 HotSpot 来说吧。对象在内存中包括三部分:对象头、实例数据和对齐填充。

#### 说说对象头的作用?
对象头是对象存储在内存中的元信息,包含了Mark Word、类型指针等信息。
Mark Word 存储了对象的运行时状态信息,包括锁、哈希值、GC 标记等。在 64 位操作系统下占 8 个字节,32 位操作系统下占 4 个字节。
类型指针指向对象所属类的元数据,也就是 Class 对象,用来支持多态、方法调用等功能。
除此之外,如果对象是数组类型,还会有一个额外的数组长度字段。占 4 个字节。
#### 类型指针会被压缩吗?
类型指针可能会被压缩,以节省内存空间。比如说在开启压缩指针的情况下占 4 个字节,否则占 8 个字节。在 JDK 8 中,压缩指针默认是开启的。
可以通过 `java -XX:+PrintFlagsFinal -version | grep UseCompressedOops` 命令来查看 JVM 是否开启了压缩指针。

如果压缩指针开启,输出结果中的 bool UseCompressedOops 值为 true。
#### 实例数据了解吗?
了解一些。
实例数据是对象实际的字段值,也就是成员变量的值,按照字段在类中声明的顺序存储。
```java
class ObjectDemo {
int age;
String name;
}
```
JVM 会对这些数据进行对齐/重排,以提高内存访问速度。
#### 对齐填充了解吗?
由于 JVM 的内存模型要求对象的起始地址是 8 字节对齐(64 位 JVM 中),因此对象的总大小必须是 8 字节的倍数。
如果对象头和实例数据的总长度不是 8 的倍数,JVM 会通过填充额外的字节来对齐。
比如说,如果对象头 + 实例数据 = 14 字节,则需要填充 2 个字节,使总长度变为 16 字节。
#### 为什么非要进行 8 字节对齐呢?
因为 CPU 进行内存访问时,一次寻址的指针大小是 8 字节,正好是 L1 缓存行的大小。如果不进行内存对齐,则可能出现跨缓存行访问,导致额外的缓存行加载,CPU 的访问效率就会降低。

比如说上图中 obj1 占 6 个字节,由于没有对齐,导致这一行缓存中多了 2 个字节 obj2 的数据,当 CPU 访问 obj2 的时候,就会导致缓存行刷新。
也就说,8 字节对齐,是为了效率的提高,以空间换时间的一种方案。

#### new Object() 对象的内存大小是多少?
推荐阅读:[高端面试必备:一个 Java 对象占用多大内存 ](https://www.cnblogs.com/rickiyang/p/14206724.html)
一般来说,目前的操作系统都是 64 位的,并且 JDK 8 中的压缩指针是默认开启的,因此在 64 位的 JVM 上,`new Object()`的大小是 16 字节(12 字节的对象头 + 4 字节的对齐填充)。

对象头的大小是固定的,在 32 位 JVM 上是 8 字节,在 64 位 JVM 上是 16 字节;如果开启了压缩指针,就是 12 字节。
实例数据的大小取决于对象的成员变量和它们的类型。对于`new Object()`来说,由于默认没有成员变量,因此我们可以认为此时的实例数据大小是 0。
假如 MyObject 对象有三个成员变量,分别是 int、long 和 byte 类型,那么它们占用的内存大小分别是 4 字节、8 字节和 1 字节。
```java
class MyObject {
int a; // 4 字节
long b; // 8 字节
byte c; // 1 字节
}
```
考虑到对齐填充,MyObject 对象的总大小为 12(对象头) + 4(a) + 8(b) + 1(c) + 7(填充) = 32 字节。
#### 用过 JOL 查看对象的内存布局吗?
用过。
[JOL](https://openjdk.org/projects/code-tools/jol/) 是一款分析 JVM 对象布局的工具。
第一步,在 pom.xml 中引入 JOL 依赖:
```xml
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.9</version>
</dependency>
```
第二步,使用 JOL 编写代码示例:
```java
public class JOLSample {
public static void main(String[] args) {
// 打印JVM详细信息(可选)
System.out.println(VM.current().details());
// 创建Object实例
Object obj = new Object();
// 打印Object实例的内存布局
String layout = ClassLayout.parseInstance(obj).toPrintable();
System.out.println(layout);
}
}
```
第三步,运行代码,查看输出结果:

可以看到有 OFFSET、SIZE、TYPE DESCRIPTION、VALUE 这几个信息。
- OFFSET:偏移地址,单位字节;
- SIZE:占用的内存大小,单位字节;
- TYPE DESCRIPTION:类型描述,其中 object header 为对象头;
- VALUE:对应内存中当前存储的值,二进制 32 位;
从上面的结果能看到,对象头是 12 个字节,还有 4 个字节的 padding,`new Object()` 一共 16 个字节。
#### 对象的引用大小了解吗?
推荐阅读:[Object o = new Object()占多少个字节?](https://www.cnblogs.com/dijia478/p/14677243.html)
在 64 位 JVM 上,未开启压缩指针时,对象引用占用 8 字节;开启压缩指针时,对象引用会被压缩到 4 字节。HotSpot 虚拟机默认是开启压缩指针的。

我们来验证一下:
```java
class ReferenceSizeExample {
private static class ReferenceHolder {
Object reference;
}
public static void main(String[] args) {
System.out.println(VM.current().details());
System.out.println(ClassLayout.parseClass(ReferenceHolder.class).toPrintable());
}
}
```
运行代码,查看输出结果:

ReferenceHolder.reference 的大小为 4 字节。
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的帆软同学 3 Java 后端一面的原题:Object a = new object()的大小,对象引用占多少大小?
> 2. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的去哪儿面经同学 1 技术二面面试原题:Object 底层的数据结构(蒙了)
> 3. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的京东同学 19 JDS 后端一面的原题:一个对象的结构是什么,包含哪些内容
memo:2025 年 8 月 14 日修改到此。[今天收到球友的反馈说](https://javabetter.cn/zhishixingqiu/),暑期拒了腾讯的客户端,暑期实习已经拿到了美团的意向,坐等 A 薪资。😄

### 10.JVM 怎么访问对象的?
主流的方式有两种:句柄和直接指针。
两种方式的区别在于,句柄是通过一个中间的句柄表来定位对象的,而直接指针则是通过引用直接指向对象的内存地址。
优点是,对象被移动时只需要修改句柄表中的指针,而不需要修改对象引用本身。

在直接指针访问中,引用直接存储对象的内存地址;对象的实例数据和类型信息都存储在堆中固定的内存区域。
优点是访问速度更快,因为少了一次句柄的寻址操作。缺点是如果对象在内存中移动,引用需要更新为新的地址。

HotSpot 虚拟机主要使用直接指针来进行对象访问。
### 11.说一下对象有哪几种引用?
四种,分别是强引用、软引用、弱引用和虚引用。

强引用是 Java 中最常见的引用类型。使用 new 关键字赋值的引用就是强引用,只要强引用关联着对象,垃圾收集器就不会回收这部分对象,即使内存不足。
```java
// str 就是一个强引用
String str = new String("沉默王二");
```
软引用于描述一些非必须对象,通过 SoftReference 类实现。软引用的对象在内存不足时会被回收。
```java
// softRef 就是一个软引用
SoftReference<String> softRef = new SoftReference<>(new String("沉默王二"));
```
弱引用用于描述一些短生命周期的非必须对象,如 ThreadLocal 中的 Entry,就是通过 WeakReference 类实现的。弱引用的对象会在下一次垃圾回收时会被回收,不论内存是否充足。
```java
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
//节点类
Entry(ThreadLocal<?> k, Object v) {
//key赋值
super(k);
//value赋值
value = v;
}
}
```
虚引用主要用来跟踪对象被垃圾回收的过程,通过 PhantomReference 类实现。虚引用的对象在任何时候都可能被回收。
```java
// phantomRef 就是一个虚引用
PhantomReference<String> phantomRef = new PhantomReference<>(new String("沉默王二"), new ReferenceQueue<>());
```
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的京东同学 4 云实习面试原题:四个引用(强软弱虚)
### 12.Java 堆的内存分区了解吗?
了解。Java 堆被划分为**新生代**和**老年代**两个区域。

新生代又被划分为 Eden 空间和两个 Survivor 空间(From 和 To)。
新创建的对象会被分配到 Eden 空间。当 Eden 区填满时,会触发一次 Minor GC,清除不再使用的对象。存活下来的对象会从 Eden 区移动到 Survivor 区。
对象在新生代中经历多次 GC 后,如果仍然存活,会被移动到老年代。当老年代内存不足时,会触发 Major GC,对整个堆进行垃圾回收。
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的得物面经同学 8 一面面试原题:Java 中堆内存怎么组织的
> 2. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的腾讯面经同学 27 云后台技术一面面试原题:怎么来区分对象是属于哪个代的?
### 13.说一下新生代的区域划分?
新生代的垃圾收集主要采用标记-复制算法,因为新生代的存活对象比较少,每次复制少量的存活对象效率比较高。
基于这种算法,虚拟机将内存分为一块较大的 Eden 空间和两块较小的 Survivor 空间,每次分配内存只使用 Eden 和其中一块 Survivor。发生垃圾收集时,将 Eden 和 Survivor 中仍然存活的对象一次性复制到另外一块 Survivor 空间上,然后直接清理掉 Eden 和已用过的那块 Survivor 空间。默认 Eden 和 Survivor 的大小比例是 8∶1。

### 14.🌟对象什么时候会进入老年代?
对象通常会在年轻代中分配,随着时间的推移和垃圾收集的进程,某些满足条件的对象会进入到老年代中,如长期存活的对象。

#### 长期存活的对象如何判断?
JVM 会为对象维护一个“年龄”计数器,记录对象在新生代中经历 Minor GC 的次数。每次 GC 未被回收的对象,其年龄会加 1。
当超过一个特定阈值,默认值是 15,就会被认为老对象了,需要重点关照。这个年龄阈值可以通过 JVM 参数`-XX:MaxTenuringThreshold`来设置。
可以通过 `jinfo -flag MaxTenuringThreshold $(jps | grep -i nacos | awk '{print $1}')` 来查看当前 JVM 的年龄阈值。

1. 如果应用中的对象存活时间较短,可以适当调大这个值,让对象在新生代多待一会儿
2. 如果对象存活时间较长,可以适当调小这个值,让对象更快进入老年代,减少在新生代的复制次数
#### 大对象如何判断?
大对象是指占用内存较大的对象,如大数组、长字符串等。
```java
int[] array = new int[1000000];
String str = new String(new char[1000000]);
```
其大小由 JVM 参数 `-XX:PretenureSizeThreshold` 控制,但在 JDK 8 中,默认值为 0,也就是说默认情况下,对象仅根据 GC 存活的次数来判断是否进入老年代。

G1 垃圾收集器中,大对象会直接分配到 HUMONGOUS 区域。当对象大小超过一个 Region 容量的 50% 时,会被认为是大对象。

Region 的大小可以通过 JVM 参数 `-XX:G1HeapRegionSize` 来设置,默认情况下从 1MB 到 32MB 不等,会根据堆内存大小动态调整。
可以通过 `java -XX:+UseG1GC -XX:+PrintGCDetails -version` 查看 G1 垃圾收集器的相关信息。

从结果上来看,我本机上 G1 的堆大小为 2GB,Region 的大小为 4MB。
#### 动态年龄判定了解吗?
如果 Survivor 区中所有对象的总大小超过了一定比例,通常是 Survivor 区的一半,那么年龄较小的对象也可能会被提前晋升到老年代。
这是因为如果年龄较小的对象在 Survivor 区中占用了较大的空间,会导致 Survivor 区中的对象复制次数增多,影响垃圾回收的效率。
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的阿里面经同学 5 阿里妈妈 Java 后端技术一面面试原题:哪些情况下对象会进入老年代?
> 2. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的京东面经同学 7 Java 后端技术一面面试原题:新生代对象转移到老年代的条件
> 3. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的拼多多面经同学 4 技术一面面试原题:对象什么时候进入老年代
memo:2025 年 1 月 13 日修改到此
### 15.STW 了解吗?
了解。
JVM 进行垃圾回收的过程中,会涉及到对象的移动,为了保证对象引用在移动过程中不被修改,必须暂停所有的用户线程,像这样的停顿,我们称之为`Stop The World`。简称 STW。
#### 如何暂停线程呢?
JVM 会使用一个名为安全点(Safe Point)的机制来确保线程能够被安全地暂停,其过程包括四个步骤:
- JVM 发出暂停信号;
- 线程执行到安全点后,挂起自身并等待垃圾收集完成;
- 垃圾回收器完成 GC 操作;
- 线程恢复执行。
#### 什么是安全点?
安全点是 JVM 的一种机制,常用于垃圾回收的 STW 操作,用于让线程在执行到某些特定位置时,可以被安全地暂停。
通常位于方法调用、循环跳转、异常处理等位置,以保证线程暂停时数据的一致性。
用个通俗的比喻,老王去拉车,车上的东西很重,老王累的汗流浃背,但是老王不能在上坡或者下坡时休息,只能在平地上停下来擦擦汗,喝口水。

推荐大家看看这个[HotSpot JVM Deep Dive - Safepoint](https://www.youtube.com/watch?v=JkbWPPNc4SI),对 safe point 有一个比较深入地解释。

### 16.对象一定分配在堆中吗?
不一定。
默认情况下,Java 对象是在堆中分配的,但 JVM 会进行逃逸分析,来判断对象的生命周期是否只在方法内部,如果是的话,这个对象可以在栈上分配。
举例来说,下面的代码中,对象 `new Person()` 的生命周期只在 `testStackAllocation` 方法内部,因此 JVM 会将这个对象分配在栈上。
```java
public void testStackAllocation() {
Person p = new Person(); // 对象可能分配在栈上
p.name = "沉默王二是只狗";
p.age = 18;
System.out.println(p.name);
}
```
#### 什么是逃逸分析?
逃逸分析是一种 JVM 优化技术,用来分析对象的作用域和生命周期,判断对象是否逃逸出方法或线程。
可以通过分析对象的引用流向,判断对象是否被方法返回、赋值到全局变量、传递到其他线程等,来确定对象是否逃逸。
如果对象没有逃逸,就可以进行栈上分配、同步消除、标量替换等优化,以提高程序的性能。
可以通过 `java -XX:+PrintFlagsFinal -version | grep DoEscapeAnalysis` 来确认 JVM 是否开启了逃逸分析。

#### 逃逸具体是指什么?
根据对象逃逸的范围,可以分为方法逃逸和线程逃逸。
当对象被方法外部的代码引用,生命周期超出了方法的范围,那么对象就必须分配在堆中,由垃圾收集器管理。
```java
public Person createPerson() {
return new Person(); // 对象逃逸出方法
}
```
比如说 `new Person()` 创建的对象被返回,那么这个对象就逃逸出当前方法了。

再比如说,对象被另外一个线程引用,生命周期超出了当前线程,那么对象就必须分配在堆中,并且线程之间需要同步。
```java
public void threadEscapeExample() {
Person p = new Person(); // 对象逃逸到另一个线程
new Thread(() -> {
System.out.println(p);
}).start();
}
```
对象 `new Person()` 被另外一个线程引用了,发生了线程逃逸。
#### 逃逸分析会带来什么好处?
主要有三个。
第一,如果确定一个对象不会逃逸,那么就可以考虑栈上分配,对象占用的内存随着栈帧出栈后销毁,这样一来,垃圾收集的压力就降低很多。
第二,线程同步需要加锁,加锁就要占用系统资源,如果逃逸分析能够确定一个对象不会逃逸出线程,那么这个对象就不用加锁,从而减少线程同步的开销。
第三,如果对象的字段在方法中独立使用,JVM 可以将对象分解为标量变量,避免对象分配。
```java
public void scalarReplacementExample() {
Point p = new Point(1, 2);
System.out.println(p.getX() + p.getY());
}
```
如果 Point 对象未逃逸,JVM 可以优化为:
```java
int x = 1;
int y = 2;
System.out.println(x + y);
```
> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的收钱吧面经同学 1 Java 后端一面面试原题:所有对象都在堆上对不对?
### 17.内存溢出和内存泄漏了解吗?
内存溢出,俗称 OOM,是指当程序请求分配内存时,由于没有足够的内存空间,从而抛出 OutOfMemoryError。
```java
List<String> list = new ArrayList<>();
while (true) {
list.add("OutOfMemory".repeat(1000)); // 无限增加内存
}
```
可能是因为堆、元空间、栈或直接内存不足导致的。可以通过优化内存配置、减少对象分配来解决。
内存泄漏是指程序在使用完内存后,未能及时释放,导致占用的内存无法再被使用。随着时间的推移,内存泄漏会导致可用内存逐渐减少,最终导致内存溢出。
内存泄漏通常是因为长期存活的对象持有短期存活对象的引用,又没有及时释放,从而导致短期存活对象无法被回收而导致的。
```java
class MemoryLeakExample {
private static List<Object> staticList = new ArrayList<>();
public void addObject() {
staticList.add(new Object()); // 对象不会被回收
}
}
```
用一个比较有味道的比喻来形容就是,内存溢出是排队去蹲坑,发现没坑了;内存泄漏,就是有人占着茅坑不拉屎,导致坑位不够用。

> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的京东面经同学 1 Java 技术一面面试原题:说说 OOM 的原因
> 2. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的快手面经同学 1 部门主站技术部面试原题:了解 OOM 吗?
### 18.能手写内存溢出的例子吗?
可以。
我就拿最常见的堆内存溢出来完成吧,堆内存溢出通常是因为创建了大量的对象,且长时间无法被垃圾收集器回收,导致的。
```java
class HeapSpaceErrorGenerator {
public static void main(String[] args) {
// 第一步,创建一个大的容器
List<byte[]> bigObjects = new ArrayList<>();
try {
// 第二步,循环写入数据
while (true) {
// 第三步,创建一个大对象,一个大约 10M 的数组
byte[] bigObject = new byte[10 * 1024 * 1024];
// 第四步,将大对象添加到容器中
bigObjects.add(bigObject);
}
} catch (OutOfMemoryError e) {
System.out.println("OutOfMemoryError 发生在 " + bigObjects.size() + " 对象后");
throw e;
}
}
}
```
很快就会发生内存溢出。
这就相当于一个房子里,不断堆积不能被回收的杂物,那么房子很快就会被堆满了。
也可以通过 VM 参数设置堆内存大小为 `-Xmx128M`,然后运行程序,出现的内存溢出的时间会更快。

可以看到,堆内存溢出发生在 11 个对象后。

> 1. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的京东面经同学 1 Java 技术一面面试原题:说说 OOM 的原因
> 2. [Java 面试指南(付费)](https://javabetter.cn/zhishixingqiu/mianshi.html)收录的快手面经同学 1 部门主站技术部面试原题:Java 哪些内存区域会发生 OOM?为什么?
memo:2025 年 1 月 14 日修改到此
### 19.内存泄漏可能由哪些原因导致呢?
比如说:
①、静态的集合中添加的对象越来越多,但却没有及时清理;静态变量的生命周期与应用程序相同,如果静态变量持有对象的引用,这些对象将无法被 GC 回收。
```java
class OOM {
static List list = new ArrayList();
public void oomTests(){
Object obj = new Object();
list.add(obj);
}
}
```