概述
本篇文章给大家带来了关于java的相关知识，主要介绍了Java之对象销毁和finalize方法的使用，具有很好的参考价值，下面一起来看一下，希望对大家有帮助。
推荐学习：《java视频教程》
对象的销毁
在C++中析构方法用于释放资源并且销毁对象本身。
在Java中，由于GC的存在，我们不需要手动回收内存，这大大减少了工作量，也提高了程序的安全性。但是Java也确实存在一个类似于C++中析构的函数。
finalize方法
重载该方法，用于在类被GC回收的时候执行一些操作。
下面是一个类实现finalize的示例。
Aoo类具有一个int 一个String属性，重载了toString并且在构造其中打印这个对象及其创建时间，在finalize中打印这个对象及调用时间。
Aoo类
public class Aoo {
private int id;
private String name;
public Aoo(){
this(0, null);
}
public Aoo(int id, String name){
this.id = id;
this.name = name;
System.out.println(this.toString() + " now create:" + System.currentTimeMillis());
}
/*
* 省略get/set/toString
*/
protected void finalize() throws Throwable{
super.finalize();
System.out.println(this.toString() + "now finalize:" + System.currentTimeMillis());
}
}登录后复制首先，一个简单的测试
main方法
public class FinalizeTest {
public static void main(String[] args) throws Exception {
Aoo a = new Aoo(1, "a");
a = null;
System.gc()
Thread.sleep(2000);
System.exit(0);
}
}登录后复制打印结果：
GC对对象的回收
这里手动调用了GC来清理内存，而如果将其注释掉System.gc();，打印结果是这样的：
也就是说，在没有特意调用GC的情况下，finalize方法根本没有被调用，也就是说这个对象根本没有被主动回收。
和想象中的不同，GC的运行方式是惰性的，也就是说，在内存没有一处的情况下，GC不会去主动回收对象，为了验证这个想法，我创建了一个线程，用于不断的消耗内存,并且不主动调用GC。
ThreadA类
public class ThreadA implements Runnable{
public void run() {
List<Integer> list = new ArrayList<Integer>();
int i = 0;
while(true){
list.add(i);
i++;
}
}
}登录后复制main方法
public class FinalizeTest {
public static void main(String[] args) throws Exception {
Aoo a = new Aoo(1, "a");
a = null;
ThreadA ta = new ThreadA();
Thread t = new Thread(ta);
t.start();
Thread.sleep(2000);
System.exit(0);
}
}登录后复制打印结果：
这一次尽管没有手动调用GC,但是finalize方法仍然运行了，也就是说，只有在内存被消耗、需要GC出面清理内存的时候，GC才会运行。
这样的finalize方法确实不靠谱，连能不能被调用都不一定，更不用说完成什么特定的操作了，如果需要关流等回收资源，不如手动调用一个方法，或者在final块中统一释放资源。
在finalize方法中，是否重新给自己指定一个引用来避免被GC回收？
尝试在finalize方法中重新引用来让GC无法回收
修改后的Aoo如下
public class Aoo {
public static Aoo SAVE = null;
private int id;
private String name;
public Aoo(){
this(0, null);
}
public Aoo(int id, String name){
this.id = id;
this.name = name;
System.out.println(this.toString() + " now create:" + System.currentTimeMillis());
}
/*
* 省略get/set/toString
*/
protected void finalize() throws Throwable{
super.finalize();
System.out.println(this.toString() + "now finalize:" + System.currentTimeMillis());
SAVE = this;
}
}登录后复制main方法
public class FinalizeTest {
public static void main(String[] args) throws Exception {
Aoo.SAVE = new Aoo(1, "a");
Aoo.SAVE = null;
System.gc();
Thread.sleep(500);
System.out.println(Aoo.SAVE == null? "a is dead" : "a is alive" );
System.exit(0);
}
}登录后复制打印结果：
这里看出，Aoo.SAVE对象确实“复活了”，不过这样的操作是有限制的，如果故技重施不会再一次“复活”该对象。
main方法
public class FinalizeTest {
public static void main(String[] args) throws Exception {
Aoo.SAVE = new Aoo(1, "a");
Aoo.SAVE = null;
System.gc();
Thread.sleep(500);
System.out.println(Aoo.SAVE == null? "a is dead" : "a is alive" );
Aoo.SAVE = null;
System.gc();
Thread.sleep(500);
System.out.println(Aoo.SAVE == null? "a is dead" : "a is alive" );
System.exit(0);
}
}登录后复制打印结果：
这里注意到，两次的操作是相同的，而finalize方法只会被系统调用一次。
如果finalze方法中出现死循环会发生什么？
Aoo类
public class Aoo {
private int id;
private String name;
public Aoo(){
this(0, null);
}
public Aoo(int id, String name){
this.id = id;
this.name = name;
System.out.println(this.toString() + " now create:" + System.currentTimeMillis());
}
/*
* 省略get/set/toString
*/
protected void finalize() throws Throwable{
super.finalize();
while(true){
System.out.println(this.toString() + "now finalize:" + System.currentTimeMillis());
Thread.sleep(100);
}
}
}登录后复制main方法
public class FinalizeTest {
public static void main(String[] args) throws Exception {
Aoo a1 = new Aoo(1 , "a1");
Aoo a2 = new Aoo(2 , "a2");
a1 = null;
a2 = null;
ThreadA ta = new ThreadA();
Thread t = new Thread(ta);
t.start();
Thread.sleep(5000);
System.exit(0);
}
}登录后复制打印结果：
结果是随机的，有时候是执行的a1的finalize，有的时候执行的是a2的。
这个结果说明了两点：
1.finalze方法在的线程优先级很低，时间间隔相当的不确定并且明显大于100毫秒。
2.这个死循环导致了别的对象的finalize方法无法执行。
如果对象的创建出现这种死循环，会不会导致对象无法销毁进而导致内存溢出？
我们大量创建Aoo对象，并且等待GC自己回收内存。
为了直观的观看finalize方法的调用情况，删除掉了Aoo对象初始化的时候的打印代码。
main方法
public class FinalizeTest {
public static void main(String[] args) throws Exception {
int i = 1;
while(true){
Aoo a = new Aoo(i , "a" + i);
i++;
}
}
}登录后复制让程序执行了约两分钟，然后手动终止，查看输出
可以发现两个情况：
1.只有一个对象的finalize方法被执行了，也就是说这个死循环的finalize方法阻止了其他对象执行finalize方法
2.程序执行很快的一段时间后，finalize方法就开始执行，但是随着内存消耗的不断增加，finalize方法被执行的次数也就越来越少。至于为什么这样，我不知道= =#
总结
至此，我尝试了finalize方法的一些用法和特殊情况。可以看出，GC调用finalize方法存在巨大的不确定性，确实很不靠谱，不过通过这个方法，了解了一些关于GC的知识，也让我明白，虽然Java语言虽然具有高度的一致性等特点使之很容易上手，但是要做到对Java的精通，路还很远呢~~
推荐学习：《java视频教程》
以上就是Java之对象销毁和finalize方法的使用的详细内容，更多请关注靠谱客其它相关文章！
最后
以上就是孤独树叶为你收集整理的Java之对象销毁和finalize方法的使用的全部内容，希望文章能够帮你解决Java之对象销毁和finalize方法的使用所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复