内存管理技术

Posted 2020-09-13 余磊

任何语言都会涉及到内存的管理和使用，很多语言要求开发人员自己进行所有内存的管理工作，如c++等。而内存管理要求的技术难度很大，很多开发人员不能很好地完成，同时也成为意向沉重的负担。

java则不同，其为内存管理提供的一套完整的解决方案——垃圾收集机制，大大减轻了开发人员编写内存管理代码的负担，减少了出错的机会，简化了开发。

一、程序中的“垃圾“”是什么

所谓垃圾，是指在内存中不再有用的对象，其占用的内存应该释放。将不再有用的对象清除出内存的工作称为“垃圾收集”。

1、对象成为“垃圾”的条件

（1）对于非线程对象来说，当所有的活动线程都不可能访问到该对象时，该对象便成为“垃圾”。

（2）对于线程对象来说，除了满足第一条标准之外，还要求此线程本身已经死亡或者还处于新建状态。

2、单个对象的情况

对于非线程的耽搁情况来说，使其成为垃圾的方法很简单，只要将指向该对象的所有引用不再指向该对象即可。

（1）将指向该对象的引用设置为null值。

//创建字符串对象，并将引用s指向该对象
String s=new String（）;
//将引用s 的值设为null值
s=null;

（2）将引用指向别的对象。

//创建字符串对象，并将引用s指向该对象
String s=new String（）;
//将引用s指向新的对象
s=new String();

（3）随着语句块或者方法的退出局部引用消亡。

//创建一个函数，当函数执行完之后，局部对象，成为垃圾被回收
public void fun(){
String s=new String("xiao");
System.out.println(s);
}

3、多个对象的孤岛情况

有引用指向的一样可能是垃圾，关键看这些对象能不能被活动线程访问到。

class Island{

//引用类型为自己的成员变量
public Island brother;
}

//创建3个Island类的对象
Island i1 =new Island();
Island i2 =new Island();
Island i3 =new Island();
//分别为三个对象中的成员变量赋值
i1.brother=i2;
i2.brother=i3;
i3.brother=i1;

//将Island的三个引用分别设置为null值
i1=null;
i2=null;
i3=null;

二、“垃圾”收集器

让对象成为垃圾的工作是由来发人员来完成的，而java中清理垃圾的工作是由垃圾收集器自动完成，不需要开发人员做很多的工作。

1、垃圾收集器的基本介绍

开发人员需要做的工作仅仅是将不需要的对象根据规则“标识”为垃圾，而垃圾收集器何时收集垃圾，如何收集垃圾都不需要开发人员关心。其实，垃圾收集器就是一个后台守护线程，在内存充足的情况下，其优先级很低，一般不会出来运行，当垃圾充斥着内存，严重影响程序执行时，其优先级会提高，并出来运行收集垃圾，清理内存。正是因为如此，垃圾收集器的运行时间是没有保障的。

2、申请垃圾收集器的运行

垃圾收集器的运行是由系统自动决定的，但是这并不是说开发人员一点都不能干预，开发人员可以通过调用特定的方法申请垃圾收集器运行。当然，在收到申请后，如果系统不是很繁忙，垃圾收集器一般都会运行，但这也没有保障。

 

Runtime类

Runtime类的对象，通过自身的getRuntime()函数获得。

                                                                         Runtime类的几个常用的方法

方法签名	功能
public static Runtime getRuntime()	该方法将返回一个当前运行程序相关的Runtime类的对象，相当于一个对象工厂。
public void gc()	申请垃圾收集器运行
public long totalMemory()	该方法将返回当前JVM使用的总内存量，单位为字节
public long freeMemory()	该方法将返回当前JVM中可使用的内存量，单位为字节

代码如下：

 1 public class javaTest {
 2    
 3     public static void main(String[] args) throws InterruptedException  {
 4         Runtime rt=Runtime.getRuntime();
 5         rt.gc();
 6         Thread.sleep(100);
 7         System.out.println("没有创建对象之前的剩余内存："+rt.freeMemory());
 8         for(int i=0;i<100000000;i++){
 9             new String("小帅哥");
10         }
11         Thread.sleep(100);
12         System.out.println("创建100个字符串对象后剩余的内存："+rt.freeMemory());
13         rt.gc();
14         Thread.sleep(100);
15         System.out.println("申请垃圾收集器运行后的剩余内存："+rt.freeMemory());
16     }
17 }

运行结果：

 1 没有创建对象之前的剩余内存：63609344 2 创建100个字符串对象后剩余的内存：58639088 3 申请垃圾收集器运行后的剩余内存：63609272 

 三、如何收集“垃圾”

对象作为垃圾清理出内存之前，可能需要进行一些扫尾的工作，在java中，这些扫尾工作的代码可以编写在被收集对象的finalize()方法中。（java中finalize()函数类似于c++中的析构函数~）

1、finalize重写

finalize方法来自Object()类，因此，每个类都有此方法。在一个对象被作为垃圾收集之前，垃圾收集器会首先调用垃圾对象的finalize()方法，然后再清除垃圾对象。

protected void finalize() throws Throwable

（1）由该方法的访问限制可以看出，因为所有的类都直接间接继承Object类，所以所有的类都可以具有该方法。

（2）对象核实被进行垃圾收集是没有保障的，有可能在整个应用程序裕兴的生命周期中一直没有进行垃圾回收，因此需要保证执行的特定的处理代码不应编写在此方法中。

（3）重写该方法时一般不但要编写自己类特定的处理代码，还应该使用“super.finalize();”调用父类的finalize()方法。因为自己特定类的对象也是一个父类的对象，父类对象的清理代码也应该执行，除非有意识的修改父类的清理对象才不需要调用父类的finalize()方法。

（4）如果没有重写该方法，则在垃圾收集时会调用父类的方法，直至追溯到Object类的finalize()方法。

 1 //父类
 2 class People{
 3 
 4     @Override
 5     protected void finalize() throws Throwable {
 6         super.finalize();
 7         System.out.println("这是people类的finalize()方法！");
 8     }    
 9 }
10 //子类
11 class Man extends People{
12     @Override
13     protected void finalize() throws Throwable {
14         super.finalize();
15         System.out.println("这是Man类的finalize()方法！");
16     }    
17 }
18 public class javaTest {
19    
20     public static void main(String[] args) throws InterruptedException {
21         //获得Runtime类对象，用于后面的申请垃圾收集器调用方法的
22         Runtime rt=Runtime.getRuntime();
23         //创建People对象
24          Man m=new Man();
25         //将对象引用指向null，让People类的对象成为垃圾
26         m=null;
27         //申请垃圾收集器运行
28         rt.gc();
29         Thread.sleep(100);            
30     }
31 }

运行结果：

 1 这是people类的finalize()方法！ 2 这是Man类的finalize()方法！ 

2、finalize安全问题

对象被执行垃圾收集前会调用其finalize()方法，如果仅仅这样，就可能带来安全问题。如果在finalize()方法中编写一些恶意的代码，在每次执行finalize()方法时使自己的对象不满足垃圾的条件，就可以组织垃圾收集，产生恶意的常驻对象。为了避免这种情况，在java中规定，一个对象的生命周期中的finalize()方法最多被执行一次。也就是说，若第一次执行垃圾收集时执行此方法阻止了垃圾收集，第二次再执行垃圾收集时不会再执行此方法，直接清除垃圾对象。

 1 class Man  {
 2     static public Man p;
 3     @Override
 4     protected void finalize() throws Throwable {
 5         super.finalize();
 6               p=this;
 7      System.out.println("这是Man类的finalize()方法！");
 8      if(p!=null){
 9         p=null;
10         System.gc();
11         Thread.sleep(100);
12         }
13         
14     }    
15 }
16 public class javaTest {
17    
18     public static void main(String[] args) throws InterruptedException {
19         //获得Runtime类对象，用于后面的申请垃圾收集器调用方法的
20         Runtime rt=Runtime.getRuntime();
21         //创建People对象
22          Man m=new Man();
23          Man m2=new Man();
24         //将对象引用建立引用循环
25          m=null;
26         
27         //申请垃圾收集器运行
28         rt.gc();
29         Thread.sleep(100);
30 
31     }
32 }

运行结果：

这是Man类的finalize()方法！

当一个对象，在其生命周期中只能执行一次finalize()函数。

四、非线程“垃圾”

通过下面一段代码，让大家了解一下非线程“垃圾”回收：

 1 class Man  {
 2 
 3     private String name;
 4     //构造函数
 5     public Man(String name) {
 6         this.name=name;
 7     }
 8     @Override
 9     protected void finalize() throws Throwable {
10         super.finalize();            
11      System.out.println(this.name+"对象被当作垃圾回收了！");        
12     }    
13 }
14 public class javaTest {
15    
16     public static void main(String[] args) throws InterruptedException {
17         //获得Runtime类对象，用于后面的申请垃圾收集器调用方法的
18         Runtime rt=Runtime.getRuntime();
19         //创建People对象
20          Man m=new Man("帅哥1");
21          Man m2=new Man("美女2");
22         //将对象引用建立引用循环
23          m=null;
24          m2=null;        
25         //申请垃圾收集器运行
26         rt.gc();
27         Thread.sleep(100);
28     }
29 }

运行结果：

 1 美女2对象被当作垃圾回收了！

2 帅哥1对象被当作垃圾回收了！ 

分析：特别注意“垃圾”的回收顺序，类似c++中的析构函数的执行顺序，先执行后被定义为垃圾的对象，是一个反的顺序。

五、线程“垃圾”

 1 class Man extends Thread {
 2 
 3     private String name;
 4     //构造函数
 5     public Man(String name) {
 6         this.name=name;
 7     }
 8     @Override
 9     public void run() {
10         // TODO Auto-generated method stub
11         super.run();
12         System.out.println("开始执行"+this.name+"线程！");
13         try {
14             Thread.sleep(1000);
15         } catch (InterruptedException e) {
16             // TODO Auto-generated catch block
17             e.printStackTrace();
18         }
19         System.out.println("即将执行完线程"+this.name);
20     }
21     @Override
22     protected void finalize() throws Throwable {
23         super.finalize();            
24      System.out.println(this.name+"对象被当作垃圾回收了！");        
25     }    
26 }
27 public class javaTest {
28    
29     public static void main(String[] args) throws InterruptedException {
30         //获得Runtime类对象，用于后面的申请垃圾收集器调用方法的
31         Runtime rt=Runtime.getRuntime();
32         //创建People对象
33          Man m=new Man("帅哥");
34          Man m2=new Man("美女");
35          Man m3=new Man("人妖");
36          m.start();
37         //将对象引用建立引用循环
38          m=null;        
39         //对无引用但活着的线程，申请垃圾收集器运行
40          System.out.println("**********对无引用但活着的线程进行垃圾回收**********");
41         rt.gc();
42         Thread.sleep(2000);
43         
44         m2=null;
45         //对无引用但处于新建状态的线程，申请垃圾收集器运行
46          System.out.println("**********对无引用但但处于新建状态的线程进行垃圾回收**********");
47         rt.gc();
48         Thread.sleep(2000);
49         
50         //执行线程m3(人妖）
51         m3.start();
52         //设置等待时间，为了使线程执行完成为死亡的线程
53         Thread.sleep(1500);
54         m3=null;
55         //对无引用死亡的线程，申请垃圾收集器运行
56          System.out.println("**********对无引用死亡的线程进行垃圾回收**********");
57         rt.gc();
58         Thread.sleep(100);    
59     }
60 }

运行结果：

 1 **********对无引用但活着的线程进行垃圾回收**********
 2 开始执行帅哥线程！
 3 即将执行完线程帅哥
 4 **********对无引用但但处于新建状态的线程进行垃圾回收**********
 5 帅哥对象被当作垃圾回收了！
 6 美女对象被当作垃圾回收了！
 7 开始执行人妖线程！
 8 即将执行完线程人妖
 9 **********对无引用死亡的线程进行垃圾回收**********
10 人妖对象被当作垃圾回收了！

结果分析：第5行的结果，是因为当线程运行结束后，成为死线程而被回收。结果显示：

对于线程对象来说，当所有的活动线程都不可能访问到该对象时，还要求此线程本身已经死亡或者还处于新建状态，则才会进行垃圾收集。活线程不会被垃圾收集~