标签：too print rgs 第一条 守护 编写 自动 rup 相关
任何语言都会涉及到内存的管理和使用，很多语言要求开发人员自己进行所有内存的管理工作，如c++等。而内存管理要求的技术难度很大，很多开发人员不能很好地完成，同时也成为意向沉重的负担。
java则不同，其为内存管理提供的一套完整的解决方案——垃圾收集机制，大大减轻了开发人员编写内存管理代码的负担，减少了出错的机会，简化了开发。
所谓垃圾，是指在内存中不再有用的对象，其占用的内存应该释放。将不再有用的对象清除出内存的工作称为“垃圾收集”。
（1）对于非线程对象来说，当所有的活动线程都不可能访问到该对象时，该对象便成为“垃圾”。
（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);
}
有引用指向的一样可能是垃圾，关键看这些对象能不能被活动线程访问到。
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中清理垃圾的工作是由垃圾收集器自动完成，不需要开发人员做很多的工作。
开发人员需要做的工作仅仅是将不需要的对象根据规则“标识”为垃圾，而垃圾收集器何时收集垃圾，如何收集垃圾都不需要开发人员关心。其实，垃圾收集器就是一个后台守护线程，在内存充足的情况下，其优先级很低，一般不会出来运行，当垃圾充斥着内存，严重影响程序执行时，其优先级会提高，并出来运行收集垃圾，清理内存。正是因为如此，垃圾收集器的运行时间是没有保障的。
垃圾收集器的运行是由系统自动决定的，但是这并不是说开发人员一点都不能干预，开发人员可以通过调用特定的方法申请垃圾收集器运行。当然，在收到申请后，如果系统不是很繁忙，垃圾收集器一般都会运行，但这也没有保障。
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++中的析构函数~）
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()方法！
对象被执行垃圾收集前会调用其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行的结果，是因为当线程运行结束后，成为死线程而被回收。结果显示：
对于线程对象来说，当所有的活动线程都不可能访问到该对象时，还要求此线程本身已经死亡或者还处于新建状态，则才会进行垃圾收集。活线程不会被垃圾收集~
标签：too print rgs 第一条 守护 编写 自动 rup 相关
原文地址：http://www.cnblogs.com/yulei126/p/6756666.html
