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
new
ArrayList
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
new
ArrayList
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
);
}
}
|