一、前言
内存结构就是 整体结构
的内存那一层
- 程序计数器
- 虚拟机栈
- 本地方法栈
- 堆
- 方法区
二、Program Counter Register 程序计数器(寄存器-各自线程独享)
- 作用,是记住下一条jvm指令的执行地址
- 特点
- 是线程私有的
- 不会存在内存溢出
2.1、图示说明
先看一个流程,如下图,左边是二进制字节码,也就是 JVM 指令,右侧是Java源代码,其编译后就是右侧的内容
其对应关系如框中所画:
右侧第一个框对应的二进制字节码就是左侧的第一个框右侧第二个框对应的二进制字节码就是左侧的第二个框
2.2、提出程序计数器
而编译成二进制字节码后,CPU还是无法调用的,所以还需要转化到CPU可以执行的指令,即将一行行的二进制字节码通过解释器(也是Java的一个组件(在执行引擎那部分))
,转变为机器码(后面你就能看到了,在学习解释器那一章,就是一堆十六进制,什么ca fa 的)
,这样CPU就可以执行这些机器码了。
好了说了那么多了,那么这个程序计数器的作用是什么呢,我们发现在上图中,最最左侧有一些数字下标,而解释器在执行的时候,需要知道下一条二进制字节码的位置,那这个下标就是位置,程序计数器就是记录这个位置的,比如
解释器 第一次执行是0号,那么在执行的时候,会把下一条的二进制字节码的位置保存在程序计数器中,也就是3保存进去,等到执行到3了,再把4保存进入,以此类推
而程序计数器是Java的称呼,其实底部(也就是物理上)使用的是计算机的内部组件 寄存器(这个在我们学习计算机组成原理的时候有说明,不懂的可以上网收索)
,而Java的程序计数器就是用寄存器对上述逻辑的封装。
2.3、程序计数器特点
2.3.1、线程私有
每个线程都会有自己的程序计数器,因为对于CPU来说,它是按照时间片来执行的,比如下图
如果CPU第一次执行到线程一的 10 号位置,时间片用完了去执行线程2了,那么线程1的程序计数器就会记住11的位置,当线程2的时间片也用用完了,回到线程1的时候,从线程1的程序计数器中读取到位置11,则接着11的位置开始执行,就不会丢失了。
2.3.2、不会存在内存溢出(OOM)
对于JVM的其它内存结构来说都会存在内存溢出,比如栈,堆等等,而程序计数器在JVM的声明中就表明它不存在内存溢出,所以实现的厂商们不需要考虑它的内存溢出的问题。
二、Java Virtual Machine Stacks (Java 虚拟机栈-各自线程独享)
- 每个线程运行时所需要的内存,称为虚拟机栈
- 每个栈由多个栈帧(Frame)组成,对应着每次方法调用时所占用的内存
- 每个线程只能有一个活动栈帧,对应着当前正在执行的那个方法
2.1、定义
2.1.1、图示说明
一个栈里面存在多个栈帧,栈帧是每一个方法运行时需要的内存,那栈帧的这个内存用来 存储什么呢,相信大家也都知道,比如方法里面的参数,局部变量,以及返回地址等。
2.1.2、代码示例
1、如下代码,可以看到我们在main这个主线程中调用了test1()方法,而test1会调用test2(),接着test2又会调用test3()。所有等下我们在test3方法哪里打个断点就可以看到main这个线程栈中会有这三个方法,而且是顺序的。
public class Test {
public static void main(String[] args) {
test1();
Date t = new Date();
System.out.println(t);
System.out.println("hello world");
}
public static void test1() {
String a = "1";
System.out.println(a);
test2();
}
public static void test2() {
String b = "2";
System.out.println(b);
test3();
}
public static void test3() {
String c = "3";
// 断点位置
System.out.println(c);
}
}
2、打上断点,执行main方法,可以看到在main()方法这个栈帧中有对于的3个方法,而且右侧有显示变量c=3,这个就是存储在栈帧内存中的。
3、而当我们test3执行完成后,test3方法占用的内存就会释放,离开栈帧,如下图
4、而且idea提供了我们选择线程栈的方式,只要点击线程栈的位置,我们就可以调试指定的栈,现在我们执行点击了main这个栈,我们也可以点击其它的栈区调试,而且通过这个我们可以很清晰的看到一个线程方法的调用,所以说线程的名称很重要,一定不要顺便乱起,或者默认。
2.2、问题辨析
2.2.1、垃圾回收是否涉及栈内存?
不涉及。因为对于栈内存来说其内部都是栈帧,而当方法执行结束后,会自动弹出栈帧,也就会被回收,不需要使用垃圾回收。
2.2.2、 栈内存分配越大越好吗?
大家也肯定想的到,并不是越大越好,如果你设置的过大,那么会影响你的线程数量,因为我们的物理总内存是一定的,比如你启动一个项目给它设置内存为400M,那么你设置每个线程栈的内存大小为20M,那么你就最多只有20个线程。我们使用默认的大小就好,这都是调试好的,默认值如下图:
可以看到除了window系统其它都是默认1M,window系统会根据你设置的总内存而动态调整,你也可以手动指定固定数值,通过在启动时设置VM参数 -Xss
2.2.3、方法内的局部变量是否线程安全?
2.2.3.1、第一种情况:如果方法内局部变量没有逃离方法的作用访问,它是线程安全的
代码如下,方法calculate 内部的变量 x 作用只是在方法内部,所以当多个线程栈的时候,并不会影响。
public class Test02 {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
executorService.execute(Test02::calculate);
executorService.execute(Test02::calculate);
System.out.println("end...");
}
public static void calculate() {
int x = 0;
for (int i = 0; i < 1000; i++) {
x++;
}
System.out.println(Thread.currentThread().getName() + ": " + x);
}
}
而且注意变量x,没有使用static,如果使用static就会变成下面这种情况了,线程也就不安全了,需要你自己区处理线程安全的措施。
2.2.3.2、第二种情况:如果是局部变量引用了对象,并逃离方法的作用范围,需要考虑线程安全
这种情况下,你得使用逻辑方法保证你的线程安全了。示例代码如下
public static void m1() {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list);
}
public static void m2(ArrayList<Integer> list) {
list.add(1);
list.add(2);
list.add(3);
System.out.println(list);
}
public static ArrayList<Integer> m3() {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
return list;
}
对于m2方法和m3方法都不能保证 变量ArrayList list
的安全(m1是可以的),举个列子对于m2方法,比如现在有2个线程,第一个线程运行的是值包含100的list,如果在m2的方法中阻塞线程(生产中是业务执行慢),那么第一个线程会很慢,那么此时已经执行到 第二个线程,而第二个线程运行的是值包含101的list,它已经直接改变了 ArrayList<Integer> a
的地址的值,导致第一个线程的值会随之改变,因为第一个线程用的也是外部的引用,2个线程用的同一个list地址,其中一个线程改变其值,会影响到另一个线程对他的使用。
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
ArrayList<Integer> a = new ArrayList<>();
a.add(100);
executorService.execute(() -> {
m2(a);
});
a.clear();
a.add(101);
executorService.execute(() -> {
m2(a);
});
}
public static void m2(ArrayList<Integer> list) {
list.add(1);
list.add(2);
list.add(3);
try {
// 假设这个地方业务执行了2秒
Thread.sleep(2 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list);
}
结果,这个结果的值是什么没什么意义的,重要的是验证了这个线程不安全的问题,至于m3方法,理论都是一样的,就不再举例了。
[101, 1, 2, 3, 1, 2, 3]
[101, 1, 2, 3, 1, 2, 3]
2.3、栈内存溢出情况
2.3.1、栈帧过多导致栈内存溢出
1、这种情况就很明显了(类似于方法的递归调用,没有终止条件),一直入栈,但是没有栈帧出栈,肯定是会满的,导致栈内存溢出
注意 内存溢出 和 内存泄漏不是一回事,下面这种情况属于内存溢出。
2.3.1.1、代码示例一(自己导致)
代码示例,下面这个main方法执行,会递归执行m1方法,而m1方法是没有终止条件的,最终栈内存溢出
public class Test04 {
private static final AtomicLong ATOMIC_LONG = new AtomicLong(0);
public static void main(String[] args) {
try {
// 使用没有终止条件的递归
m1();
} catch (Throwable e) {
e.printStackTrace();
System.out.println(ATOMIC_LONG.get());
}
}
public static void m1() {
ATOMIC_LONG.incrementAndGet();
m1();
}
}
当然为了方便快速显示,我们设置栈的内存大小为256k
2.3.1.2、代码示例二(第三方jar,不适当使用导致)
我们使用jackson的序列化来说明一个案例,下面这个案例会导致,jackson在序列化的时候,出现死循环
public class Test05 {
public static void main(String[] args) throws JsonProcessingException {
Dept development = new Dept();
development.setName("研发");
Staff zhangSan = new Staff("张三",development);
Staff liSi = new Staff("李四",development);
development.setStaffList(Arrays.asList(zhangSan,liSi));
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.writeValueAsString(development);
}
}
/**
* 部门
*/
class Dept {
private String name;
/**
* 当前部门其下所有员工
*/
private List<Staff> staffList;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Staff> getStaffList() {
return staffList;
}
public void setStaffList(List<Staff> staffList) {
this.staffList = staffList;
}
public Dept(String name, List<Staff> staffList) {
this.name = name;
this.staffList = staffList;
}
public Dept() {
}
}
/**
* 员工
*/
class Staff {
private String name;
/**
* 属于那个部门
*/
private Dept dept;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
public Staff() {
}
public Staff(String name, Dept dept) {
this.name = name;
this.dept = dept;
}
}
出现死循环的原因如下,在序列化到staffList时,每一个staff又需要dept,就这样一直陷入了死循环
{"name":"研发","staffList":[{"name":"张三","dept":{"name":"研发","staffList":[{"name":"...."}]}},{"name":"李四"}]}
解决上面的问题,你可以自己修改代码的业务逻辑,或者,在序列化的时候,将员工的dept不给予序列化如下,加上 @JsonIgnore
注解即可。
/**
* 属于那个部门
*/
@JsonIgnore
private Dept dept;
2.3.2、栈帧过大
不过这种情况一半不会出现,你可以想一下,假设我们现在使用默认的栈内存大小 1M,则1M = 1024KB = 1048576(1024*1024)B = 8388608 b,而我们的一个int 才占用 4B ,所以下面这种情况 几乎不可能发生,除非你自定义了栈内存大小,设置的太小了。
注意 1M对于栈的存储来说肯定是足够的,就存储一个int ,string,对象地址等等,因为具体的数据存储还是在堆中。
2.4、线程运行诊断
2.4.1、cpu 占用过多
1、后台运行一个项目
2、使用top查看到CPU使用率很高
3、看看这个进程里面是那个线程占用率高
其中 -H:显示进程的层次,-e:命令之后显示环境,-o:用户自定义格式。后面就是我们需要展示的内容了,最后使用grep过滤其它进程信息,只看32655的进程的线程信息。最后我们可以看到是线程32665 使用的CPU很高
4、使用jstack确认问题
先使用jstack 32655(这个是进程id),可以看到这个进程里面有很多线程,
那有那么多线程,我们这么确认是那个线程有问题呢,这个时候我们就要用到第三步骤种查出的线程Id,只不过那是十进制的,我们转化一下,看到十六进制后是 0x7F99,所以,我们就定位到问题了
而且也就定位到具体的代码位置了,然后我们看下源代码即可。
5、总结
-
用top定位哪个进程对cpu的占用过高
-
ps H -eo pid,tid,%cpu | grep 进程id (用ps命令进一步定位是哪个线程引起的cpu占用过高)
-
jstack 进程id(查看java进程的具体信息,看是那个线程有问题,根据上一步查出的线程号)
- 再根据线程id 找到有问题的线程,进一步定位到问题代码的源码行号
但是在实际生产中,这种方式可能就不是那么实用了,因为那个飙高线程的id可能一瞬间就执行完成了,还没等你定位到问题,有换成了另一个线程id继续飙高了。
2.4.2、程序运行很长时间没有结果(可能是死锁了)
1、运行一个程序
2、使用 jstack 32752
命令查看到最后面,看到它显示有一个死锁,是因为线程一和线程二互相等待锁导致的,分别在Demo1_3的29行和Demo1_3的21行。
3、查看对应的代码,至于为什么是死锁,我就不解释了,相信大家都能看懂。
三、本地方法栈(各自线程独享)
定义:JVM调用一些本地方法时,提供的内存
因为Java本身的限制,不能直接调用一些操作系统的方法,只能通过C,C++来调用,然后Java再去调用C,C++的方法,间接去调用操作系统。而那些用C,C++写好的方法,在Java中称作本地方法,用 native 修饰符修饰。
举一个列子,比如 java中的 Object
类,里面很多都是本地方法
四、堆(所有线程共享)
4.1、定义
- Heap 堆
- 通过 new 关键字,创建对象都会使用堆内存
- 特点
- 它是线程共享的,堆中对象都需要考虑线程安全的问题
- 有垃圾回收机制
4.1.1、代码示例
对于下面2个线程来说变量a都是在各自的线程栈内存中,但是 new ArrayList(2);
会在堆内存中,而a会使用其地址,那堆又说是线程不安全的,但是下面这个代码我们之前在栈那一章节已经证明过了,是线程安全的,是栈内存独有的,这是为什么呢,请看第二张图
public class Test06 {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
executorService.execute(Test06::m1);
executorService.execute(Test06::m1);
}
public static void m1() {
List<Integer> a = new ArrayList(2);
a.add(1);
}
}
这张图就解释了上面的问题,虽然 new ArrayList(2);
会在堆内存中,但是这2个线程使用的并不是同一个,而是重新创建,各自使用各自的。所以前面在栈那章的线程安全问题哪里的验证都是成立的,如果此时你把这个list提取到方法参数让外部传入,还是一样的线程不安全,理论是一样的,其实主要就是大家是不是各自使用各自的。
4.2、堆内存溢出
因为 new ArrayList<>()
在堆中,这里一直在死循环的添加元素,最后会抛出 java.lang.OutOfMemoryError: Java heap space,注意这里是OOM,而前面的栈那一章节是 StackOverFlowError,一个是堆内存溢出,一个是栈内存溢出错误。
所以我们就说1M对于栈的存储来说肯定是足够的,就存储一个int ,string,对象地址等等,具体的数据存储还是在堆中。
public class Test07 {
public static void main(String[] args) {
int i = 0;
String a = "hello";
List<String> list = new ArrayList<>();
try {
while (true) {
i++;
list.add(a);
a = a + a;
}
} catch (Throwable e) {
e.printStackTrace();
System.out.println(i);
}
}
}
在上面的实验中,我们也可以手动调整堆内存大小,通过调整VM参数
-Xms 设置最小
-Xmx 设置最大
4.3、堆内存诊断
1、jps 工具
查看当前系统中有哪些 java 进程
2、jmap 工具
查看堆内存占用情况 jmap - heap 进程id
3、jconsole 工具
图形界面的,多功能的监测工具,可以连续监测
这些命令都在jdk的bin目录下,记得要配置到环境变量中,不然不方便使用。
4.3.1、jps和jmap工具使用示例
1、示例代码如下
public class Test08 {
public static void main(String[] args) throws InterruptedException {
System.out.println("1....");
Thread.sleep(30 * 1000);
// 10M
byte[] array = new byte[1024 * 1024 * 10];
System.out.println("2....");
Thread.sleep(30 * 1000);
array = null;
System.gc();
System.out.println("3....");
Thread.sleep(30000 * 1000);
}
}
2、运行后,在控制台输出 1 后,我们执行jps,查看这个示例的进程id,可以看到是 27896
Test08这个。
3、在控制台没有输出 2 时,我们接着执行 jmap -heap 27896
查看进程id是27896的堆内存情况,输出结果如下,因为此刻还没有到2哪里,
// 10M
byte[] array = new byte[1024 * 1024 * 10];
就还没有分配 这个10M的内存,所以,下面这个堆的信息就是初始化的时候。
Attaching to process ID 27896, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.181-b13
using thread-local object allocation.
Parallel GC with 13 thread(s)
Heap Configuration: //堆内存配置
MinHeapFreeRatio = 0 // 最小堆内存比例
MaxHeapFreeRatio = 100 // 最大堆内存比例
MaxHeapSize = 3980394496 (3796.0MB) // 最大堆内存,这里是3796.0MB
NewSize = 82837504 (79.0MB) // 堆的新生代初始化为79.0MB
MaxNewSize = 1326448640 (1265.0MB) // 堆的新生代最大为 1265.0MB
OldSize = 166723584 (159.0MB) // 堆的老年代为 159.0MB
NewRatio = 2 // 堆的新生代中form和to区的占比内存 0.2
SurvivorRatio = 8 // 堆的新生代中eden区的占比内存 0.8
MetaspaceSize = 21807104 (20.796875MB) // 堆的初始元数据空间内存 20.796875MB
CompressedClassSpaceSize = 1073741824 (1024.0MB) // 不了解,请上网搜索
MaxMetaspaceSize = 17592186044415 MB // 堆的最大元数据空间内存 17592186044415 MB
G1HeapRegionSize = 0 (0.0MB) // 不了解,请上网搜索
Heap Usage: //堆的使用情况
PS Young Generation // 新生代
Eden Space: //新生代中的 伊甸园
capacity = 62914560 (60.0MB) //伊甸园 初始 (60.0MB)
used = 8859904 (8.449462890625MB) //伊甸园 已经使用的 (8.449462890625MB)
free = 54054656 (51.550537109375MB) //伊甸园 空闲的 (51.550537109375MB)
14.082438151041666% used //伊甸园内存使用占比
From Space: //新生代中的 from区
capacity = 9961472 (9.5MB) //新生代中的 from区 初始化内存大小(9.5MB)
used = 0 (0.0MB) //新生代中的 from区已经使用的
free = 9961472 (9.5MB) //新生代中的 from区空闲的 (9.5MB)
0.0% used //新生代中的 from区 内存使用占比
To Space: //新生代中的 to 区
capacity = 9961472 (9.5MB) //新生代中的 to 区 初始化内存大小
used = 0 (0.0MB) //新生代中的 to 区已经使用的
free = 9961472 (9.5MB) //新生代中的 to 区空闲的 (9.5MB)
0.0% used //新生代中的 to 区 内存使用占比
PS Old Generation //老年代
capacity = 166723584 (159.0MB) //老年代 初始化内存大小
used = 0 (0.0MB) //老年代已经使用的
free = 166723584 (159.0MB) //老年代 空闲的内存
0.0% used //老年代 内存使用占比
3181 interned Strings occupying 260688 bytes.
4、等控制台输出2后,我们再执行 jmap -heap 27896
查看进程id是27896的堆内存情况,输出结果如下,此刻还没有输出3,所以那10M的内存还在堆中占用着,可以看到 Eden Space 中的使用的区域增加了10M,变成了 used = 19345680 (18.449478149414062MB),说明那个10M的byte数组内存分配到了 伊甸园。
Attaching to process ID 27896, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.181-b13
using thread-local object allocation.
Parallel GC with 13 thread(s)
Heap Configuration:
MinHeapFreeRatio = 0
MaxHeapFreeRatio = 100
MaxHeapSize = 3980394496 (3796.0MB)
NewSize = 82837504 (79.0MB)
MaxNewSize = 1326448640 (1265.0MB)
OldSize = 166723584 (159.0MB)
NewRatio = 2
SurvivorRatio = 8
MetaspaceSize = 21807104 (20.796875MB)
CompressedClassSpaceSize = 1073741824 (1024.0MB)
MaxMetaspaceSize = 17592186044415 MB
G1HeapRegionSize = 0 (0.0MB)
Heap Usage:
PS Young Generation
Eden Space:
capacity = 62914560 (60.0MB)
used = 19345680 (18.449478149414062MB)
free = 43568880 (41.55052185058594MB)
30.749130249023438% used
From Space:
capacity = 9961472 (9.5MB)
used = 0 (0.0MB)
free = 9961472 (9.5MB)
0.0% used
To Space:
capacity = 9961472 (9.5MB)
used = 0 (0.0MB)
free = 9961472 (9.5MB)
0.0% used
PS Old Generation
capacity = 166723584 (159.0MB)
used = 0 (0.0MB)
free = 166723584 (159.0MB)
0.0% used
3182 interned Strings occupying 260744 bytes.
5、等控制台输出3后,我们再执行 jmap -heap 27896
查看进程id是27896的堆内存情况,输出结果如下,此刻已经手动将byte 数组赋值为 null,并手动执行了 GC,所以那10M的内存不会在堆中占用着,可以看到 Eden Space 中的使用的区域又减少了10M,变成了 used = 1258304 (1.20001220703125MB)
好像不止10M,哈哈哈,反正就是那个意思。
Attaching to process ID 27896, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.181-b13
using thread-local object allocation.
Parallel GC with 13 thread(s)
Heap Configuration:
MinHeapFreeRatio = 0
MaxHeapFreeRatio = 100
MaxHeapSize = 3980394496 (3796.0MB)
NewSize = 82837504 (79.0MB)
MaxNewSize = 1326448640 (1265.0MB)
OldSize = 166723584 (159.0MB)
NewRatio = 2
SurvivorRatio = 8
MetaspaceSize = 21807104 (20.796875MB)
CompressedClassSpaceSize = 1073741824 (1024.0MB)
MaxMetaspaceSize = 17592186044415 MB
G1HeapRegionSize = 0 (0.0MB)
Heap Usage:
PS Young Generation
Eden Space:
capacity = 62914560 (60.0MB)
used = 1258304 (1.20001220703125MB)
free = 61656256 (58.79998779296875MB)
2.0000203450520835% used
From Space:
capacity = 9961472 (9.5MB)
used = 0 (0.0MB)
free = 9961472 (9.5MB)
0.0% used
To Space:
capacity = 9961472 (9.5MB)
used = 0 (0.0MB)
free = 9961472 (9.5MB)
0.0% used
PS Old Generation
capacity = 166723584 (159.0MB)
used = 1038488 (0.9903793334960938MB)
free = 165685096 (158.0096206665039MB)
0.6228800839598074% used
3168 interned Strings occupying 259760 bytes.
4.3.2、 jconsole 工具使用示例
1、代码还是 4.3.1 节的示例代码,这个工具能,是连续检测的,比起上面我们使用 jmap
只能查看某一刻的状态要好很多。当然也是在java的bin目录下的。
如下我们看到堆内存先一下子拔高,就是我们分配内存了,然后一下子降低,说明到了执行gc哪里。
2、并且这个工具也可以替代 jstack
查看线程和检测死锁等等,你可以点击线程查看具体的详情
3、而且在内存详情的页面还有一个执行GC的按钮,也就是说我们可以点击它来完成手动执行GC。
其实这个工具还是不错的,而且还有一些收费的观察JVM的工具和不收费的观察工具。比如 JProfile,我觉得就很不错。当然这些后面都会说到。
4.3.3、案例-jvisualvm
1、现在有一个珠海的平台,内存占用一直很高(但是之前的版本没有那么高的内存占用,所以是这次更新的问题),而且你发现Java已经自己做过了几次GC但是,效果还是很不理想,于是你使用 jvisualvm
(也是在Java的bin目录下) 链接进去查看,点击链接后,右侧会出现这个项目的一些信息,感觉和 jconsole 差不多,但是也有一些它自己的特点。
2、现在已经连接到你的珠海的项目了Test09这个项目,于是你手动执行下GC,想看看效果,发现并没有减少
3、所以你现在想看看堆里面都有些啥,于是你把到此刻的堆信息给保存为快照,慢慢分析,点击了右侧的 堆Dump
4、那现在已经把之前的堆的数据信息保存为快照了,接下来就是分析了,你点击右侧的查找,想去找到堆中最消耗内存的前20个对象
5、发现有很多的VehicleIo 对象和 一个list对象,分别占用1M和200M,于是你点击list查看,里面是什么存储了200M,而且GC一直无法回收。点进去查看后发现,这个list的大小是200,里面的元素就说VehicleIo,那么就有200M了,
6、根据第五步骤,已经确认是这个list里面存储了太多的vehilceIo对象,而这个vehicleIo对象一个竟要1M,所以你应该能想到你项目哪里用到了这个,问题代码如下
public class Test09 {
private static final int COUNT = 200;
public static void main(String[] args) throws InterruptedException {
List<VehicleIo> list = new ArrayList<>(COUNT);
for (int i = 0; i < COUNT; i++) {
list.add(new VehicleIo());
}
// 阻塞线程 模拟线上正在运行的环境
Thread.sleep(1000 * 1000 * 1000);
}
}
/**
* 车辆io 对象
*/
class VehicleIo {
/**
* 假设每一个 车辆io 用到的报文都说 1M
*/
private byte[] message = new byte[1024 * 1024];
}
7、这个工具还是很不错的,你可以多多探索,还有一个和它一样的工具 ,JProfiler 。
但是在window上有一个问题,就是它无法获取到变成win服务的tomcat,解决方案网上有很多。
jdk自带VisualVM无法监控到注册成服务的tomcat
五、方法区(所有线程共享)
5.1、定义
官方在Java8的文档中定义 Chapter 2. The Structure of the Java Virtual Machine 这个可以去看看,里面有很多的JVM的定义,都说官方发布的,比较的权威。
翻译内容如下
Java 虚拟机有一个在所有 Java 虚拟机线程之间共享的方法区。方法区类似于传统语言的编译代码的存储区,或者类似于操作系统进程中的“文本”段。它存储每个类的结构,例如运行时常量池、字段和方法数据,以及方法和构造函数的代码,包括类和实例初始化和接口初始化中使用的特殊方法(第 2.9 节,一般指的是类的构造器)。
方法区是在虚拟机启动时创建的。尽管方法区在逻辑上是堆的一部分,但简单的实现可能会选择不进行垃圾收集或压缩它。本规范不要求方法区域的位置或用于管理已编译代码的策略。方法区域可以是固定大小,也可以根据计算需要扩大,如果不需要更大的方法区域,可以缩小。方法区的内存不需要是连续的。
Java 虚拟机实现可以为程序员或用户提供对方法区域初始大小的控制,以及在方法区域大小可变的情况下,对最大和最小方法区域大小的控制。
以下异常情况与方法区相关:
如果方法区域中的内存无法满足分配请求,Java 虚拟机将抛出 OutOfMemoryError。
从官方的定义中我们可以了解到:方法区是规范
- Oracle的HotSpot虚拟机对其实现有:永久代(1.8之前)和元数据空间(1.8之后)
- Eclipse (IBM)的虚拟机 J9 好像没有实现吧,em…不清楚,自己上网可以搜索一下
至于其它的厂家实现的JVM,中方法区的实现这里就不再多说了。
5.2 组成
5.2.1、Oracle的HotSpot在1.6中方法区
可以看到其实现叫做永久代,里面存储了常量池,class的属性,以及class的信息,和类加载器,而且要注意一定,此时的方法区的内存占用还是在JVM的内存中,也就是我们给JVM分配的内存大小中,1.8之后就不再是了
5.2.1、Oracle的HotSpot在1.8中方法区
1、和1.6很大的不同就是它的内存不在JVM中,而是用的本地内存,这个本地内存就是指你的操作系统,也就说说你给JVM分配了4个G的大小,这个方法区是不会占用这个4G内存的,而是使用你操作系统的内存。
2、第二点就是方法区的实现换成了元空间,里面存储了class的属性,以及class的信息,和类加载器,但是和1.6不同,它将常量池放到了堆中。
3、第三点,这个方法区内存还会使用启动一些其它进程。
4、串池的位置也从方法去换到到堆(Heap)中
5.3 方法区内存溢出
1、我们将很多的类装配至一个类中,再限制一下方法区大小,这样在加载的时候就会出现方法区溢出了 示例代码如下
public class Test10 extends ClassLoader {
/**
* 记得方法区大小,不然,不容易测试出来
* 1.8设置元空间大小 -XX:MaxMetaspaceSize=8m
* 1.8之前设置永久代大小 -XX:MaxPermSize=8m
* @param args
*/
public static void main(String[] args) {
int j = 0;
try {
Test10 test10 = new Test10();
for (int i = 0; i < 100000; i++, j++) {
// ClassWriter 的作用是生产类的二进制字节码
ClassWriter classWriter = new ClassWriter(0);
// 定义一个类 版本(1.8,1.7),修饰符(public),类名(Class0,Class1...),包名(null),父类(Object),接口(null)
classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
// 将上面生产的类转成二进制字节码
byte[] bytes = classWriter.toByteArray();
// 装配到test10这个对象中,这样test10这个对象中就会有很多的上面生成的类(Class0,Class1...),都会保存在方法区中
test10.defineClass("Class" + i, bytes, 0, bytes.length);
}
} catch (Throwable e) {
System.out.println(j);
e.printStackTrace();
}
}
}
2、因为方法区默认情况下使用的是系统内存,所以下面的两个实验要增加对应的参数,限制方法区大小
1.8设置元空间大小 -XX:MaxMetaspaceSize=10m
1.8之前设置永久代大小 -XX:MaxPermSize=10m
5.3.1、1.8 之前会导致永久代内存溢出
运行结果,也可以看出是 PermGen space 永久代实现的方法区。
5.3.2、1.8 之后会导致元空间内存溢出
运行结果
5.3.3、场景
-
spring
spring 中用到了 cglib 区处理aop
-
mybatis
mybatis中的mapper接口,需要用到cglib生成代理,关联对应的xml文件,区帮助我们生成对应的mapper的实现类。
但是cglib 其实底层也是使用我们前面示例中的 ClassWriter
类来动态生成二进制字节码的。但是现在方法区已经换成的系统内存(如果你不设置的话),可能这种情况就很少出现了,如果出现了,可以考虑下是不是框架使用的不合理。
5.4、运行时常量池
5.4.1、常量池
1、想要知道什么是运行时常量池,就要知道什么是常量池,示例代码如下,可以看到就是一个简单的输出
*/
public class Test11 {
public static void main(String[] args) {
System.out.println("hello JVM");
}
}
2、我们找到这个类的二进制字节码文件,使用 javap
命令来反编译,这样我们就能稍微看懂些了。执行命令javap -v .\Test01.class
,反编译结果如下
后面的那些 注释的java代码是 javap 帮我们加上的,实际是没有的
// 类基本信息
Classfile /D:/code/exercise/jvm/target/classes/cn/gxm/test01/Test11.class
Last modified 2022-3-16; size 547 bytes
MD5 checksum 3d0cb910aad16d9d908ff774fa15f10b
Compiled from "Test11.java"
public class cn.gxm.test01.Test11
minor version: 0 // java的最小版本(不是我们说的jdk1.7,jdk1.8,它这是内部的版本)
major version: 52 // java的最大版本 这个52其实就说对应我们的jdk1.8
flags: ACC_PUBLIC, ACC_SUPER
// 常量池(这就是常量池了) 后面有很多注释,其实这都是javap 帮助我们生成的,方便我们不用一个地址一个地址的找,比如
// #1 = Methodref #6.#20 //你要知道 #1 就得区找#15 和 #20 ,一步一步的找,直到最后找到信息
Constant pool:
#1 = Methodref #6.#20 // java/lang/Object."<init>":()V
#2 = Fieldref #21.#22 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #23 // hello JVM
#4 = Methodref #24.#25 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = Class #26 // cn/gxm/test01/Test11
#6 = Class #27 // java/lang/Object
#7 = Utf8 <init>
#8 = Utf8 ()V
#9 = Utf8 Code
#10 = Utf8 LineNumberTable
#11 = Utf8 LocalVariableTable
#12 = Utf8 this
#13 = Utf8 Lcn/gxm/test01/Test11;
#14 = Utf8 main
#15 = Utf8 ([Ljava/lang/String;)V
#16 = Utf8 args
#17 = Utf8 [Ljava/lang/String;
#18 = Utf8 SourceFile
#19 = Utf8 Test11.java
#20 = NameAndType #7:#8 // "<init>":()V
#21 = Class #28 // java/lang/System
#22 = NameAndType #29:#30 // out:Ljava/io/PrintStream;
#23 = Utf8 hello JVM
#24 = Class #31 // java/io/PrintStream
#25 = NameAndType #32:#33 // println:(Ljava/lang/String;)V
#26 = Utf8 cn/gxm/test01/Test11
#27 = Utf8 java/lang/Object
#28 = Utf8 java/lang/System
#29 = Utf8 out
#30 = Utf8 Ljava/io/PrintStream;
#31 = Utf8 java/io/PrintStream
#32 = Utf8 println
#33 = Utf8 (Ljava/lang/String;)V
// 类方法定义
{
public cn.gxm.test01.Test11();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1 // 一个栈,一个变量,参数数量一个
0: aload_0 // 将卡槽中的0号位置(就是this,可以看LocalVariableTable),放入到栈中去(这里看不懂后面会说的)
1: invokespecial #1 // Method java/lang/Object."<init>":()V 调用方法
4: return
LineNumberTable:
line 8: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcn/gxm/test01/Test11;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=1, args_size=1 // 一个栈,一个变量,参数数量一个(就是args,虽然没有值)
// 获取Out 变量,这么找到的 你可以到常量池中的 #2,一步一步的找,就会发现是Out变量
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
// 加载字符串 hello JVM (你可以到常量池中的 #3 ,一步一步的找)
3: ldc #3 // String hello JVM
// 调用我们的out.println 参数据就是 hello JVM (你可以到常量池中的 #4 ,一步一步的找)
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 11: 0
line 12: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 args [Ljava/lang/String;
}
SourceFile: "Test11.java"
3、我们见到上面的反编译结果后,初步可以分为三个部分
- 类基本信息
- 常量池
- 类方法定义
- 虚拟机指令
其中 Constant pool 部分就是我们所说的常量池
5.4.2、运行时常量池
-
常量池,就是一张表,虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息 (上面5.4.1已经说明了)
字面量:比如前面的 hello JVM就是,如果你有一些int的数值,那么也是字面量信息
-
运行时常量池,常量池是 *.class 文件中的常量池,当该类被加载,它的常量池信息就会放入内存中存贮,变成运行时常量池,并把里面的符号地址变为真实地址
上面的5.4.1中是把java代码转变为了二进制字节码,区分出了常量池,那么我们在运行的时候,会把那个区分出来的常量池加载到内存中存贮,并且这只是一个文件,如果有多个文件中都有
hello JVM
这样的字面量,在内存就只有一份,这就叫运行时常量池。并且我们会把里面的那些 #1,#6.#20 这些下标,转化为对应的内存地址,因为已经将这些数据加载到内存中了,直接记住内存地址即可。
5.5、stringTable(串池)
用到的运行时常量池的对象,会被保存到stringTable(串池)中。
只有被用到才会加载到其中(比如 String s1 = “a”,此时的字符串a 才会从运行时常量池中加载到串池中。),懒惰式的。
5.5.1、举例说明一
1、示例代码
public class Test12 {
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
String s3 = "c";
}
}
2、首先我们使用 javac
编译这个文件,得出二进制字节码文件,我们再使用 javap
命令查看得出如下内容
Classfile /D:/code/exercise/jvm/target/classes/cn/gxm/test01/Test12.class
Last modified 2022-3-16; size 497 bytes
MD5 checksum a55c3bfcf0e23f9498589c410a8964d2
Compiled from "Test12.java"
public class cn.gxm.test01.Test12
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #6.#24 // java/lang/Object."<init>":()V
#2 = String #25 // a
#3 = String #26 // b
#4 = String #27 // c
#5 = Class #28 // cn/gxm/test01/Test12
#6 = Class #29 // java/lang/Object
#7 = Utf8 <init>
#8 = Utf8 ()V
#9 = Utf8 Code
#10 = Utf8 LineNumberTable
#11 = Utf8 LocalVariableTable
#12 = Utf8 this
#13 = Utf8 Lcn/gxm/test01/Test12;
#14 = Utf8 main
#15 = Utf8 ([Ljava/lang/String;)V
#16 = Utf8 args
#17 = Utf8 [Ljava/lang/String;
#18 = Utf8 s1
#19 = Utf8 Ljava/lang/String;
#20 = Utf8 s2
#21 = Utf8 s3
#22 = Utf8 SourceFile
#23 = Utf8 Test12.java
#24 = NameAndType #7:#8 // "<init>":()V
#25 = Utf8 a
#26 = Utf8 b
#27 = Utf8 c
#28 = Utf8 cn/gxm/test01/Test12
#29 = Utf8 java/lang/Object
{
public cn.gxm.test01.Test12();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 8: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcn/gxm/test01/Test12;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=4, args_size=1
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String c
8: astore_3
9: return
LineNumberTable:
line 18: 0
line 19: 3
line 20: 6
line 21: 9
LocalVariableTable:
Start Length Slot Name Signature
0 10 0 args [Ljava/lang/String;
3 7 1 s1 Ljava/lang/String;
6 4 2 s2 Ljava/lang/String;
9 1 3 s3 Ljava/lang/String;
}
SourceFile: "Test12.java"
3、此时我们得出 字符串 “a”,“b”,"ab"都已经在常量池中的了
#2 = String #25 // a
#3 = String #26 // b
#4 = String #27 // c
4、当我们运行这个程序的时候,大家也都知道运行的是这个二进制字节码,会把上述的常量池加载到内存中存储,并把 #2,#25 ....
这类的下标替换为内存地址,成为运行时常量池。然后我们开始读取main代码,就是从上面截取下来的。
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=4, args_size=1
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String c
8: astore_3
9: return
LineNumberTable:
line 18: 0
line 19: 3
line 20: 6
line 21: 9
LocalVariableTable:
Start Length Slot Name Signature
0 10 0 args [Ljava/lang/String;
3 7 1 s1 Ljava/lang/String;
6 4 2 s2 Ljava/lang/String;
9 1 3 s3 Ljava/lang/String;
5、此时对于整个运行的项目会有一个空白的串池(stringTable),其内部实现是 hashTable(key 就是对于的字符串),且不能扩容。它里面存储的就是你项目用到的运行时常量池对象。
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=4, args_size=1
0: ldc #2 // String a # 加载字符串a,并加入到 串池(stringTable)中,因为此时串池(stringTable)中没有a,所以可以直接把a加进去
2: astore_1 // 存储到卡槽的1号位置的变量中(下面的LocalVariableTable 里面有卡槽的下边,可以看到1号卡槽对应的是s1变量)
3: ldc #3 // String b # 加载字符串b,并加入到 串池
5: astore_2 // 存储到卡槽的2号位置的变量中(下面的LocalVariableTable 里面有卡槽的下边,可以看到2号卡槽对应的是s2变量)
6: ldc #4 // String c # 加载字符串c,并加入到 串池
8: astore_3 // 存储到卡槽的3号位置的变量中(下面的LocalVariableTable 里面有卡槽的下边,可以看到3号卡槽对应的是s3变量)
9: return
LineNumberTable:
line 18: 0
line 19: 3
line 20: 6
line 21: 9
LocalVariableTable:
Start Length Slot Name Signature
0 10 0 args [Ljava/lang/String;
3 7 1 s1 Ljava/lang/String;
6 4 2 s2 Ljava/lang/String;
9 1 3 s3 Ljava/lang/String;
最后 空白的串池(stringTable)已经不再是空白的了,里面存有 【“a”,“b”,“c”】
5.5.2、举例说明二
1、我们在5.5.1节的基础上,再次说明,和上面的唯一区别就是加了2行不同的,但是根据前面的实验我们已经知道如果执行到s3的位置时,此时串池(stringTable)中肯定会有 【“a”,“b”,“ab”】
public static void main(String[] args) {
// 懒惰加载到串池中
String s1 = "a";
String s2 = "b";
String s3 = "ab";
String s4 = s1 + s2;
}
2、现在比较迷惑的就是s4地方的代码,我们先编译成二进制字节码后,再使用javap
来反编译,这里只截取main方法的内存,其它的意义不大,如下
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=5, args_size=1
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String ab
8: astore_3
// 执行到这里串池(stringTable)中肯定会有 【"a","b","ab"】,
// 至于下面这一部分,大家估计也能看懂就是 调用 StringBuilder.append("a").append("b").toString() 并赋值给卡槽的4号位置就是变量s4
9: new #5 // class java/lang/StringBuilder
12: dup
13: invokespecial #6 // Method java/lang/StringBuilder."<init>":()V
16: aload_1
17: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
20: aload_2
21: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
24: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
27: astore 4
29: return
LineNumberTable:
line 16: 0
line 17: 3
line 18: 6
line 19: 9
line 20: 29
LocalVariableTable:
Start Length Slot Name Signature
0 30 0 args [Ljava/lang/String;
3 27 1 s1 Ljava/lang/String;
6 24 2 s2 Ljava/lang/String;
9 21 3 s3 Ljava/lang/String;
29 1 4 s4 Ljava/lang/String;
3、根据上面的解释我们了解了 s4 = StringBuilder.append("a").append("b").toString()
,而我们发现
StringBuilder的toString方法是new 一个字符串
5、所以现在第一个问题,是ture,还是false,很明显答案是false,因为 == 默认比较的是内存地址,而s3的内存地址在串池中,s4指向一个新的内存地址(堆中),因为它使用的是new出来的字符串。
System.out.println(s3 == s4);
5.5.3、举例说明三
1、我们在5.5.1节的基础上,加一个示例,和上面的唯一区别就是加了1行不同的,但是根据前面的实验我们已经知道如果执行到s3的位置时,此时串池(stringTable)中肯定会有 【“a”,“b”,“ab”】
public static void main(String[] args) {
// 懒惰加载到串池中
String s1 = "a";
String s2 = "b";
String s3 = "ab";
String s5 = "a" + "b";
System.out.println(s5 == s3);
}
2、现在比较迷惑的就是s5地方的代码,我们先编译成二进制字节码后,再使用javap
来反编译,这里只截取main方法的内存,其它的意义不大,如下
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=3, locals=5, args_size=1
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String ab
8: astore_3
// 执行到这里串池(stringTable)中肯定会有 【"a","b","ab"】,
// 重要的是这9,10两步,你发现他是直接 拿到了字符串 ab 将其赋值给变量s5(存储到4号卡槽,就是变量s5)
9: ldc #4 // String ab
11: astore 4
//接下来就是比较了,这里重点不在这,暂时不说了。相信大家也能看懂
13: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
16: aload 4
18: aload_3
19: if_acmpne 26
22: iconst_1
23: goto 27
26: iconst_0
27: invokevirtual #6 // Method java/io/PrintStream.println:(Z)V
30: return
LineNumberTable:
line 16: 0
line 17: 3
line 18: 6
line 20: 9
line 21: 13
line 22: 30
LocalVariableTable:
Start Length Slot Name Signature
0 31 0 args [Ljava/lang/String;
3 28 1 s1 Ljava/lang/String;
6 25 2 s2 Ljava/lang/String;
9 22 3 s3 Ljava/lang/String;
13 18 4 s5 Ljava/lang/String;
StackMapTable: number_of_entries = 2
frame_type = 255 /* full_frame */
offset_delta = 26
locals = [ class "[Ljava/lang/String;", class java/lang/String, class java/lang/String, class java/lang/String, class java/lang/String ]
stack = [ class java/io/PrintStream ]
frame_type = 255 /* full_frame */
offset_delta = 0
locals = [ class "[Ljava/lang/String;", class java/lang/String, class java/lang/String, class java/lang/String, class java/lang/String ]
stack = [ class java/io/PrintStream, int ]
}
SourceFile: "Test12.java"
3、根据上面的解释我们了解了 s5 = “ab”)
,而我们发现 9,10两步,你发现他是直接 拿到了字符串 ab 将其赋值给变量s5(存储到4号卡槽,就是变量s5),所以结果,是ture,还是false?,很明显答案是true,因为 == 默认比较的是内存地址,而s3和s4的地址都是串池中字符串“ab”
System.out.println(s5 == s3);
4、其实这个和 举例说明2中 不一样的原因是 示例2中是使用变量拼接,java在编译的时候并不知道具体的值,只能先用对象去接收,其结果是在堆中的,但是示例3中,不同,它直接使用字符串常量去拼接,所以java在编译期间就知道最后的值,而当准备放进串池的时候,发现串池中已经有了,那么就拿来直接用就好。
5.5.4、举例说明四
示例代码如下,我们证明一下如果串池中已经存在的字符串常量,那么再次加载的时候,用的还是串池的那一份
public class Test13 {
public static void main(String[] args) {
System.out.println("start...");
System.out.println("0");
System.out.println("1");
System.out.println("2");
System.out.println("3");
System.out.println("4");
System.out.println("5");
System.out.println("6");
System.out.println("7");
System.out.println("8");
System.out.println("9");
System.out.println("0");
System.out.println("1");
System.out.println("2");
System.out.println("3");
System.out.println("4");
System.out.println("5");
System.out.println("6");
System.out.println("7");
System.out.println("8");
System.out.println("9");
}
}
5.5.5、手动将字符串入串池
1、我们可以使用字符串的 intern()
方法手动将字符串**尝试放入串池中。注意尝试**两个字:
s.intern();方法将这个字符串尝试放入串池,如果串池中已经有了则不会放入,如果没有则放入串池,并且无论最后有没有成功放入进去,一定会把串池中的对象地址给返回
public class Test14 {
public static void main(String[] args) {
// 因为这里使用new,所以, new String("a") 和 new String("b") 都是在堆中的,当然变量s是在栈中的
// 而字符串常量 “a”,“b” 会在常量池,运行时常量池,以及串池中都有一份
String s = new String("a") + new String("b");
// 此时调用intern,因为现在串池中还没有 "ab",所以会将自己堆内存的"ab"放入串池中,并返回内存地址,并修改s的引用地址为串池中的"ab"地址
String s1 = s.intern();
// true 因为此刻我们拿来比较的"ab"就是串池中的地址
System.out.println(s == "ab");
// true 因为此刻我们拿来比较的"ab"就是串池中的地址
System.out.println(s1 == "ab");
}
}
2、如果我们把字符串 “ab” 提前一步呢,如下
public class Test14 {
public static void main(String[] args) {
// 直接放入串池中
String x = "ab";
// 但是此时的s用的是堆中的"ab"地址
String s = new String("a") + new String("b");
// 想放进去串池中,但是放不了,因为里面已经有 "ab"了,并把串池中的 "ab" 地址返回了
// 因为没有放进去,所以s 还是用的是堆中的"ab"地址
String s1 = s.intern();
// true
System.out.println(s1 == x);
// false
System.out.println(s == x);
}
}
3、判断结果
如下代码在jdk1.8的情况下的结果是什么
String s1 = "a";
String s2 = "b";
String s3 = "a" + "b";
String s4 = s1 + s2;
String s5 = "ab";
String s6 = s4.intern();
// 问
System.out.println(s3 == s4);
System.out.println(s3 == s5);
System.out.println(s3 == s6);
String x2 = new String("c") + new String("d");
String x1 = "cd";
x2.intern();
// 问,如果调换了【最后两行代码】的位置呢,如果是jdk1.6呢(1.6先不了解,容易把自己搞晕)
System.out.println(x1 == x2);
String x3 = new String("a") + new String("b");
System.out.println(x3 == s4);
如下解释,都在代码里,各位好汉请看
public class Test14 {
public static void main(String[] args) {
String s1 = "a";
String s2 = "b";
// 编译期优化,直接入串池(因为都是常量不会变),所以用的串池中的 "ab" 地址
String s3 = "a" + "b";
// 用的是stringBuilder().appned().toString 而toString() 是new string()所以s4用的是在堆中的"ab"的地址
String s4 = s1 + s2;
// 用的串池中的 "ab" 地址
String s5 = "ab";
// 想将s4堆中的"ab"的地址放入串池 但是失败了,因为串池里面已经有了,并返回了串池的“ab”地址(注意s4并没有变)
// 所以s6用的是串池的 "ab"的地址
String s6 = s4.intern();
// 串池"ab"地址 == 堆中的"ab"的地址 ( false)
System.out.println(s3 == s4);
// 串池"ab"地址 == 串池"ab"地址 ( true)
System.out.println(s3 == s5);
// 串池"ab"地址 == 串池"ab"地址 ( true)
System.out.println(s3 == s6);
// 用的是 stringBuilder().appned().toString 而toString() 是new string()所以 x2 用的是在堆中的"cd"的地址
String x2 = new String("c") + new String("d");
// 串池中存有 "cd" 地址
String x1 = "cd";
// 想将x2堆中的"cd"的地址放入串池 但是失败了,因为串池里面已经有了,并返回了串池的“cd”地址(注意x2并没有变)
x2.intern();
// false
System.out.println(x1 == x2);
// 问,如果调换了【最后两行代码 String x1 = "cd"; x2.intern();】的位置呢,如果是jdk1.6呢(1.6先不了解,容易把自己搞晕)
// 如果互换的话 结果就是 true
// 用的是 stringBuilder().appned().toString 而toString() 是new string()所以 x3 用的是在堆中的"ab"的地址(新new的),但是不是和s4的同一个地址
String x3 = new String("a") + new String("b");
System.out.println(x3 == s4); //false
}
}
5.5.6、StringTable的位置
其实前面已经有过介绍了,不同的jdk版本存放的位置也不同,如果你想要实验,记得根据不同jdk版本设置一个较小的内存来测试。
5.5.7、StringTable 垃圾回收
这里需要说明一点 串池也是会被垃圾回收的,我们接下来做一个实验证明这一点,当然我们使用的是JDK1.8,所以串池是在堆内存的,为了方便实验,表示堆内存不够的时,串池也是会被回收的,那么我们就先限制堆内存的大小,这样一旦我们实验中加入过多的字符串入串池,就能看出来是否进行了串池的垃圾回收了,添加VM参数如下:
/**
* -Xmx10m 限制堆内存最大为100M
* -XX:+PrintStringTableStatistics 将串池信息打印出来,方便我们查看
* -XX:+PrintGCDetails 将GC执行时的信息打印出来,这样我们就知道有没有执行GC了
* -verbose:gc 在程序运行的时候有多少gc 被加载 具体使用可以参考:https://www.cnblogs.com/ezgod/p/14538591.html
*/
-Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
1、我们先运行一份干净的代码,看看初始的版本是什么样子
public class Test15 {
public static void main(String[] args) {
int i = 0;
try {
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println(i);
}
}
结果
0 // 输出的i
// 堆信息
Heap
PSYoungGen total 2560K, used 1951K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
eden space 2048K, 95% used [0x00000000ffd00000,0x00000000ffee7fc0,0x00000000fff00000)
from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
to space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
ParOldGen total 7168K, used 0K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
object space 7168K, 0% used [0x00000000ff600000,0x00000000ff600000,0x00000000ffd00000)
Metaspace used 3360K, capacity 4496K, committed 4864K, reserved 1056768K
class space used 369K, capacity 388K, committed 512K, reserved 1048576K
// 这一千多个字符串常量(13967 ),是我们的类名属性名之类的,
SymbolTable statistics:
Number of buckets : 20011 = 160088 bytes, avg 8.000
Number of entries : 13967 = 335208 bytes, avg 24.000
Number of literals : 13967 = 596368 bytes, avg 42.698
Total footprint : = 1091664 bytes
Average bucket size : 0.698
Variance of bucket size : 0.702
Std. dev. of bucket size: 0.838
Maximum bucket size : 6
// 这一部分就是我们的串池信息可以看到现在是 1762 个,我们主要观察这个
StringTable statistics:
Number of buckets : 60013 = 480104 bytes, avg 8.000
Number of entries : 1762 = 42288 bytes, avg 24.000
Number of literals : 1762 = 157904 bytes, avg 89.616
Total footprint : = 680296 bytes
Average bucket size : 0.029
Variance of bucket size : 0.029
Std. dev. of bucket size: 0.172
Maximum bucket size : 2
2、我们增加串池的数量(增加100个)
public class Test15 {
public static void main(String[] args) {
int i = 0;
try {
for (int j = 0; j < 100; j++) {
// 调用 intern 手动使其入串池 注意我们这里只是创建了,但是没有引用偶
// 所以说如果我们推理正确的话(StringTable 是可以被垃圾回收的),那么内存不足时它是可以被回收的
String.valueOf(j).intern();
i++;
}
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println(i);
}
}
结果,这里就是展示 串池的信息了,发现是1862 = (1762 + 100),证明这100个是加入到串池中了,但是现在并没有发现回收的信息,所以接下来我们加大数量
StringTable statistics:
Number of buckets : 60013 = 480104 bytes, avg 8.000
Number of entries : 1862 = 44712 bytes, avg 24.000
Number of literals : 1862 = 162776 bytes, avg 87.373
Total footprint : = 687592 bytes
Average bucket size : 0.031
Variance of bucket size : 0.031
Std. dev. of bucket size: 0.176
Maximum bucket size : 2
Process finished with exit code 0
3、我们增加串池的数量(增加10000个)
public class Test15 {
public static void main(String[] args) {
int i = 0;
try {
for (int j = 0; j < 10000; j++) {
// 调用 intern 手动使其入串池 注意我们这里只是创建了,但是没有引用偶,所以说如果我们推理正确的话(StringTable 是可以被垃圾回收),内存不足时它是可以被回收的
String.valueOf(j).intern();
i++;
}
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println(i);
}
}
结果发生了mingr GC,而且发现现在的数量是8857 ,所以StringTable 是可以被垃圾回收的
// 发生了一次GC
[GC (Allocation Failure) [PSYoungGen: 2048K->496K(2560K)] 2048K->722K(9728K), 0.0022356 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
// 串池信息
StringTable statistics:
Number of buckets : 60013 = 480104 bytes, avg 8.000
Number of entries : 8857 = 212568 bytes, avg 24.000
Number of literals : 8857 = 498808 bytes, avg 56.318
Total footprint : = 1191480 bytes
Average bucket size : 0.148
Variance of bucket size : 0.159
Std. dev. of bucket size: 0.399
Maximum bucket size : 3
5.5.8、StringTable 性能调优
- 调整 -XX:StringTableSize=桶个数
- 考虑将字符串对象是否入池
5.5.8.1、调整 -XX:StringTableSize=桶个数
1、StringTable (串池)是底层是一个hash表,桶的个数越多,hash碰撞的几率就越小,后续链表的长度就越短,所以我们只需要根据我们的项目的实际情况调整桶的个数即可。
2、示例代码如下,我们读取一文件这个文件有40多万行,每一行就一个单词,我们把他们读取出来后,都让其入串池。最后打印耗费的毫秒值。
3、在我们添加下列参数,将桶个数设置为 200000 后再运行一次,就发现快很多,大概快200毫秒左右。
-XX:StringTablesize=200000 -XX:+PrintstringTablestatistics
4、打印的结果信息 Number of buckets
就是我们设置的通个数的值。
// 串池信息
StringTable statistics:
Number of buckets : 200000 = 480104 bytes, avg 8.000
Number of entries : 8857 = 212568 bytes, avg 24.000
Number of literals : 8857 = 498808 bytes, avg 56.318
Total footprint : = 1191480 bytes
Average bucket size : 0.148
Variance of bucket size : 0.159
Std. dev. of bucket size: 0.399
Maximum bucket size : 3
5.5.8.2、考虑将字符串对象是否入池
下面案例我们都是设置了VM参数,设置了堆内存大小的,方便看出效果。
-Xmx500m
1、如下案例,我们模拟 10 * 40万 个地址,假设这个400万个地址,我们都需要加载到内存中,这消耗会很大,字符串内存占用几乎达到90%
linux.word文件有40万行,一行一个单词
2、但是这个地址有很多都是重复的,我们可以通过 串池的 inter()方法来过滤那些重复的数据,修改完成后可以看到字符串只占用了30%多的内存
address.add(line.inter())
5.5.9、总结
-
常量池中的字符串仅是符号,第一次用到时才变为对象
-
利用串池的机制,来避免重复创建字符串对象
-
字符串**变量**拼接的原理是 StringBuilder (1.8)(s1 = s2+s3)
-
字符串**常量**拼接的原理是编译期优化 (s1 = “a”+“b”)
-
可以使用 intern 方法,主动将串池中还没有的字符串对象放入串池
-
1.8 将这个字符串对象尝试放入串池,如果有则不会放入,如果没有则放入串池, 最后无论是否放入成功都会把串池中的对象地址返回
-
1.6 将这个字符串对象尝试放入串池,如果有则并不会放入,如果没有会把此对象复制一份,
放入串池, 会把串池中的对象返回
-
只要是变量的字符串拼接用的一定是 StringBuilder.append().toString(),例如
// 这其实也是用StringBuilder
String x2 = new String("c") + new String("d");
// 这其实也是用StringBuilder
String s4 = s1 + s2;
5.6、常量池、运行时常量池、串池的总结
-
关于 常量池,运行时常量池,以及串池我这里有一些自己的见解,可能不是很正确,我们在编写代码时,用到了一个常字符串 “ab”,那么经过
javac
命令编译成二进制字节码,这个“abc”字符串就会在一个叫做 constant pool的区域部分,此时还是在一个*.class文件中,*我们称此时的 .class文件中的 constant pool的区域部分叫做 常量池 -
后一步就是java解释器将这些二进制字节码转为cpu可以运行的机器码
-
再一步,运行这些机器码后,我们刚刚的字符串“ab”,就会保存到内存中(1.8是元数据使用的是系统内存),那么此时我们称这个保存字符串“ab”的区域为运行时常量池
-
那么一个程序总会有一个入口,比如我们运行的main方法,假设现在有一行代码要用到字符串"ab",比如
String s1 = "ab";
-
那么此时先去运行时常量池找到字符串 “ab”,再保存到串池中,如果串池中有了,就直接拿来用,没有就先保存进去,再拿来用。
-
所以只有被用到才会加载到其中(比如 String s1 = “ab”,此时的字符串 “ab” 才会从运行时常量池中加载到串池中。),懒惰式的。
六、直接内存
6.1、定义
不是JVM的内存,而是操作系统的内存
- 常见于 NIO 操作时,用于数据缓冲区
- 分配回收成本较高,但读写性能高
- 不受 JVM 内存回收管理,但是当调用system.gc时如果引用的对象已经不再使用,那么这个直接内存也会被回收。(因为用的系统内存,肯定不受它管理,至于为system.gc可以回收不使用的直接内存后面会说的)
6.2、jvm内存与直接内存对比
1、如下案例,我们对同一个视频文件(大约800M)读取,写入到另一个文件中,但是我们缓冲区一个 使用普通 IO 的 byte[1M]
和直接内存 ByteBuffer.allocateDirect(_1Mb);
,缓冲区都是1M,可以看到3次的耗时
类型 | 第一次耗时 | 第二次耗时 | 第三次耗时 |
---|---|---|---|
IO 的 byte[1M] | 1535.586957 | 1766.963399 | 1359.240226 |
直接内存 ByteBuffer.allocateDirect(_1Mb); | 479.295165 | 702.291454 | 562.56592 |
public class Test16 {
static final String FROM = "E:\\code\\vide\\youtube\\Getting Started with Spring Boot-sbPSjI4tt10.mp4";
static final String TO = "E:\\a.mp4";
static final int _1Mb = 1024 * 1024;
public static void main(String[] args) {
io(); // io 用时:1535.586957 1766.963399 1359.240226
directBuffer(); // directBuffer 用时:479.295165 702.291454 562.56592
}
private static void directBuffer() {
long start = System.nanoTime();
try (FileChannel from = new FileInputStream(FROM).getChannel();
FileChannel to = new FileOutputStream(TO).getChannel();
) {
ByteBuffer bb = ByteBuffer.allocateDirect(_1Mb);
while (true) {
int len = from.read(bb);
if (len == -1) {
break;
}
bb.flip();
to.write(bb);
bb.clear();
}
} catch (IOException e) {
e.printStackTrace();
}
long end = System.nanoTime();
System.out.println("directBuffer 用时:" + (end - start) / 1000_000.0);
}
private static void io() {
long start = System.nanoTime();
try (FileInputStream from = new FileInputStream(FROM);
FileOutputStream to = new FileOutputStream(TO);
) {
byte[] buf = new byte[_1Mb];
while (true) {
int len = from.read(buf);
if (len == -1) {
break;
}
to.write(buf, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
long end = System.nanoTime();
System.out.println("io 用时:" + (end - start) / 1000_000.0);
}
}
2、那么为什么快呢,先看使用IO的,因为java不能直接调用系统的函数,也就是通过native方法来调用,这时java会从用户态转为内核态,而读取磁盘文件不是一下子全部读取完的,是一部分一部分的读取,避免撑爆内存,它首先会将1M的数据放入系统缓存区,因为Java不能使用系统的,所以它会再堆内存中开辟一块 Java缓冲区byte[],来存放那个系统缓存区的1M数据,这样Java才可以操作,这样一份数据要流转2次保存2次,显然是很慢的。
2、再看使用直接内存的,唯一的不同是,Java堆内存和系统内存都可以直接访问 这个直接内存,这样,1M的数据只需要流转1次,保存1次即可。
6.3、直接内存溢出
1、直接内存也是会导致内存溢出的OOM,但是提示信息会打印 Direct buffer memory
public class Test17 {
private static final int _100M = 100 * 1024 * 1024;
public static void main(String[] args) {
int i = 0;
List<ByteBuffer> list = new ArrayList<>();
try {
while (true) {
// 将每次分配的100M的直接内存放到list中引用,避免被回收
list.add(ByteBuffer.allocateDirect(_100M));
i++;
}
} catch (Throwable e) {
System.out.println(i);
e.printStackTrace();
}
}
}
2、结果
33
java.lang.OutOfMemoryError: Direct buffer memory
at java.nio.Bits.reserveMemory(Bits.java:694)
at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
at cn.gxm.one.Test17.main(Test17.java:22)
6.4、分配和回收原理
6.4.1、java中如何分配直接内存(系统内存)
1、其实java中是通过 unsafe.allocateMemory(_1Gb);
来分配直接内存,再通过unsafe.freeMemory(base);
释放直接内存的
public class Test18 {
static int _1Gb = 1024 * 1024 * 1024;
public static void main(String[] args) throws IOException {
Unsafe unsafe = getUnsafe();
// 分配直接内存,并返回这块直接内存的地址
long base = unsafe.allocateMemory(_1Gb);
unsafe.setMemory(base, _1Gb, (byte) 0);
System.in.read();
// 释放直接内存
unsafe.freeMemory(base);
System.in.read();
}
/**
* 通过反射获取 Unsafe 类
*
* @return unsafe
*/
public static Unsafe getUnsafe() {
try {
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
// 注意我们在通过反射获取静态属性的时候,或者激活津泰方法的时候,只需要将参数中的调用对象改为null即可,因为static本就是所有实例对象共享的
Unsafe unsafe = (Unsafe) f.get(null);
return unsafe;
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
2、我们没有运行main方法,看下直接内存,当然我们不能通过之前的jmap
,jconsole
等等工具来看,因为那些工具只能看到JVM管理的,对于直接内存因为使用的是系统内存,所以我们可以直接看win的任务管理,可以看到没有运行main时占用了3G左右
3、分配成功
4、释放成功
5、所以我们可以得出,java是通过unsafe
类来操作系统函数再来操作直接内存的。
6.4.2、为什么通过system.gc可以回收直接内存?
1、效果我就不再演示了,我们通过调用 System.gc();
就会回收没有使用的直接内存。
public class Test19 {
static int _1Gb = 1024 * 1024 * 1024;
public static void main(String[] args) throws IOException {
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1Gb);
System.out.println("分配完毕...");
System.in.read();
System.out.println("开始释放...");
// 引用置空 ,可以回收
byteBuffer = null;
// 显式的垃圾回收,Full GC
System.gc();
System.in.read();
}
}
2、我们点击进入ByteBuffer.allocateDirect(_1Gb);
的方法内部查看,果然还是通过 unsafe
来分配内存,那么肯定也是通过它来释放内存,那么会在哪里呢?
3、创建直接内存的时候,可以看到一个Cleaner
类
4、这个类我们点进去看,它是一个实现了虚引用的类
5、我们看到它的clear
方法,里面就是调用传入参数的一个线程任务
6、而这个任务其实就是调用 unsafe
的清除内存的方法
7、所以我们可以得出,一旦使用直接内存的对象,被垃圾回收掉了,那么就会一个实现了虚引用的Cleaner
类的clear()方法,而clear方法里面会调用传入的参数的一个名为Deallocator
的任务,而Deallocator
的里面实现就是调用 unsafe.freeMemory(address);
来清除直接内存。