|
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
|
package com.charles.research;
/**
*
*
这是一个Person类，我用它来撑满heap
*
@author charles.wang
*
*/
public class Person
{
private String
name;
private String
sex;
private int age;
public Person(
String name,String sex,int age){
this.name=name;
this.sex=sex;
this.age=age;
}
public String
getName() {
return name;
}
public void setName(String
name) {
this.name
= name;
}
public String
getSex() {
return sex;
}
public void setSex(String
sex) {
this.sex
= sex;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age
= age;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/**
*
造成内存溢出，这次重复添加一个Person对象到一个列表中，因为列表是强引用，所以无法被回收，
*
从而最终导致内存溢出
*/
public static void makeOutOfMemory1(){
//无限往一个List中加对象，因为List是强引用，所以不会被GC，从而导致memory溢出
List<Person>
persons = new ArrayList<Person>
();
while( 1>0){
persons.add( new Person("fakeperson","male",25));
}
}
|
|
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
|
package com.charles.research;
/**
*
*
这是一个CompanyPerson类，它会引用到Person类，并且加入了一些额外属性，比如员工号，收入，职位
*
@author charles.wang
*
*/
public class CompanyPerson
{
//引用Person类
private Person
person;
private String
employeeId;
private double salary;
private String
position;
public CompanyPerson(
Person person, String employeeId, double salary,String
position){
this.person
= person;
this.employeeId
= employeeId;
this.salary
= salary;
this.position
= position;
}
public Person
getPerson() {
return person;
}
public void setPerson(Person
person) {
this.person
= person;
}
public String
getEmployeeId() {
return employeeId;
}
public void setEmployeeId(String
employeeId) {
this.employeeId
= employeeId;
}
public double getSalary()
{
return salary;
}
public void setSalary(double salary)
{
this.salary
= salary;
}
public String
getPosition() {
return position;
}
public void setPosition(String
position) {
this.position
= position;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/**
*
造成内存溢出，这次重复添加一个CompanyPerson对象到一个列表中,而CompanyPerson对象是引用Person对象的，因为列表是强引用，所以无法被回收，
*
从而最终导致内存溢出
*/
public static void makeOutOfMemory2(){
//无限往一个List中加对象，因为List是强引用，所以不会被GC，从而导致memory溢出
List<CompanyPerson>
companyPersons = new ArrayList<CompanyPerson>
();
while( 1>0){
Person
person = new Person("fackperson","male",25);
CompanyPerson
cp = new CompanyPerson(person,"emp123",20000L,"SSE");
companyPersons.add(
cp);
}
}
|
|
1
2
3
4
5
6
7
8
9
10
|
/**
*
这个不会造成内存溢出，因为我们每次都在Heap上创建对象，但是这个对象是弱引用对象，所以会被回收
*/
public static void makeOutOfMemory3(){
//无限创建一个Person对象
while( 1>0){
Person
person = new Person("fackperson","male",25);
}
}
|
