Java之对象销毁和finalize方法的使用

WBOY

发布时间：2022-07-28 15:31:03

1871人浏览过

来源于脚本之家

转载

本篇文章给大家带来了关于java的相关知识，主要介绍了java之对象销毁和finalize方法的使用，具有很好的参考价值，下面一起来看一下，希望对大家有帮助。

Java之对象销毁和finalize方法的使用

推荐学习：《java视频教程》

对象的销毁

在C++中析构方法用于释放资源并且销毁对象本身。

在Java中，由于GC的存在，我们不需要手动回收内存，这大大减少了工作量，也提高了程序的安全性。但是Java也确实存在一个类似于C++中析构的函数。

立即学习“Java免费学习笔记（深入）”；

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

打印结果：

Android数据格式解析对象JSON用法 WORD版

本文档主要讲述的是Android数据格式解析对象JSON用法；JSON可以将Java对象转成json格式的字符串，可以将json字符串转换成Java。比XML更轻量级，Json使用起来比较轻便和简单。JSON数据格式，在Android中被广泛运用于客户端和服务器通信，在网络数据传输与解析时非常方便。希望本文档会给有需要的朋友带来帮助；感兴趣的朋友可以过来看看

下载

id:1 name:a now create:1497547723036id:1 name:anow finalize:1497547724059

GC对对象的回收

这里手动调用了GC来清理内存，而如果将其注释掉System.gc();，打印结果是这样的：

id:1 name:a now create:1497547846923

也就是说，在没有特意调用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);
       }
}

打印结果：

id:1 name:a now create:1497548135268
id:1 name:anow finalize:1497548135386

这一次尽管没有手动调用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);             
       }
}

打印结果：

id:1 name:a now create:1497551409195
id:1 name:anow finalize:1497551409201
a is alive

这里看出，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);          
       }
}

打印结果：

id:1 name:a now create:1497551587715
id:1 name:anow finalize:1497551587721
a is alive
a is dead

这里注意到，两次的操作是相同的，而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);
       }
}

打印结果：

id:1 name:a1 now create:1497552024252
id:2 name:a2 now create:1497552024252
id:1 name:a1now finalize:1497552024373
id:1 name:a1now finalize:1497552024503
id:1 name:a1now finalize:1497552026848
id:1 name:a1now finalize:1497552028960
id:1 name:a1now finalize:1497552032363

结果是随机的，有时候是执行的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++;
              }
       }
}

让程序执行了约两分钟，然后手动终止，查看输出

1497554225913
id:269614 name:a269614now finalize:1497554226151
id:269614 name:a269614now finalize:1497554227635
id:269614 name:a269614now finalize:1497554227735
id:269614 name:a269614now finalize:1497554227836
id:269614 name:a269614now finalize:1497554229586
id:269614 name:a269614now finalize:1497554229686
id:269614 name:a269614now finalize:1497554229951
id:269614 name:a269614now finalize:1497554230051
id:269614 name:a269614now finalize:1497554230152
id:269614 name:a269614now finalize:1497554233699
id:269614 name:a269614now finalize:1497554233800
id:269614 name:a269614now finalize:1497554233900
id:269614 name:a269614now finalize:1497554234308
id:269614 name:a269614now finalize:1497554234408
id:269614 name:a269614now finalize:1497554234508
id:269614 name:a269614now finalize:1497554235053
id:269614 name:a269614now finalize:1497554235153
id:269614 name:a269614now finalize:1497554235253
id:269614 name:a269614now finalize:1497554235823
id:269614 name:a269614now finalize:1497554235923
id:269614 name:a269614now finalize:1497554236023
id:269614 name:a269614now finalize:1497554240324
id:269614 name:a269614now finalize:1497554240424
id:269614 name:a269614now finalize:1497554240525
id:269614 name:a269614now finalize:1497554241146
id:269614 name:a269614now finalize:1497554241241247
id:269614 name:a269614now finalize:1497554241347
id:269614 name:a269614now finalize:1497554241448
id:269614 name:a269614now finalize:1497554242020
id:269614 name:a269614now finalize:1497554242120
id:269614 name:a269614now finalize:1497554242220
id:269614 name:a269614now finalize:1497554242321
id:269614 name:a269614now finalize:1497554242421
id:269614 name:a269614now finalize:1497554242521
id:269614 name:a269614now finalize:1497554248367
id:269614 name:a269614now finalize:1497554248467
id:269614 name:a269614now finalize:1497554248567
id:269614 name:a269614now finalize:1497554248667
id:269614 name:a269614now finalize:1497554249534
id:269614 name:a269614now finalize:1497554249634
id:269614 name:a269614now finalize:1497554249734
id:269614 name:a269614now finalize:1497554249835
id:269614 name:a269614now finalize:1497554255954
id:269614 name:a269614now finalize:1497554256055
id:269614 name:a269614now finalize:1497554256155
id:269614 name:a269614now finalize:1497554256255
id:269614 name:a269614now finalize:1497554256356
id:269614 name:a269614now finalize:1497554257285
id:269614 name:a269614now finalize:1497554257386
id:269614 name:a269614now finalize:1497554257486
id:269614 name:a269614now finalize:1497554257586
id:269614 name:a269614now finalize:1497554257686
id:269614 name:a269614now finalize:1497554268652
id:269614 name:a269614now finalize:1497554268753
id:269614 name:a269614now finalize:1497554268853
id:269614 name:a269614now finalize:1497554268953
id:269614 name:a269614now finalize:1497554269054
id:269614 name:a269614now finalize:1497554269154
id:269614 name:a269614now finalize:1497554277474
id:269614 name:a269614now finalize:1497554292852
id:269614 name:a269614now finalize:1497554301062

可以发现两个情况：

1.只有一个对象的finalize方法被执行了，也就是说这个死循环的finalize方法阻止了其他对象执行finalize方法

2.程序执行很快的一段时间后，finalize方法就开始执行，但是随着内存消耗的不断增加，finalize方法被执行的次数也就越来越少。至于为什么这样，我不知道= =#

总结

至此，我尝试了finalize方法的一些用法和特殊情况。可以看出，GC调用finalize方法存在巨大的不确定性，确实很不靠谱，不过通过这个方法，了解了一些关于GC的知识，也让我明白，虽然Java语言虽然具有高度的一致性等特点使之很容易上手，但是要做到对Java的精通，路还很远呢~~

推荐学习：《java视频教程》

如何自定义Java异常类_业务逻辑错误封装方案

Java中的内部类有什么作用_成员内部类与外部类的访问权限

如何在Java中将项目部署到Linux服务器_nohup后台运行与标准输出重定向日志

如何实现Java的观察者模式_接口回调机制实战应用

Java Preferences API 的正确使用与配置文件路径误区解析

java速学教程(入门到精通)

java怎么学习？java怎么入门？java在哪学？java怎么学才快？不用担心，这里为大家提供了java速学教程(入门到精通)，有需要的小伙伴保存下载就能学习啦！

下载

相关专题

C# ASP.NET Core微服务架构与API网关实践

本专题围绕 C# 在现代后端架构中的微服务实践展开，系统讲解基于 ASP.NET Core 构建可扩展服务体系的核心方法。内容涵盖服务拆分策略、RESTful API 设计、服务间通信、API 网关统一入口管理以及服务治理机制。通过真实项目案例，帮助开发者掌握构建高可用微服务系统的关键技术，提高系统的可扩展性与维护效率。

2026.03.11

Go高并发任务调度与Goroutine池化实践

本专题围绕 Go 语言在高并发任务处理场景中的实践展开，系统讲解 Goroutine 调度模型、Channel 通信机制以及并发控制策略。内容包括任务队列设计、Goroutine 池化管理、资源限制控制以及并发任务的性能优化方法。通过实际案例演示，帮助开发者构建稳定高效的 Go 并发任务处理系统，提高系统在高负载环境下的处理能力与稳定性。

2026.03.10

Kotlin Android模块化架构与组件化开发实践

本专题围绕 Kotlin 在 Android 应用开发中的架构实践展开，重点讲解模块化设计与组件化开发的实现思路。内容包括项目模块拆分策略、公共组件封装、依赖管理优化、路由通信机制以及大型项目的工程化管理方法。通过真实项目案例分析，帮助开发者构建结构清晰、易扩展且维护成本低的 Android 应用架构体系，提升团队协作效率与项目迭代速度。

2026.03.09

JavaScript浏览器渲染机制与前端性能优化实践

本专题围绕 JavaScript 在浏览器中的执行与渲染机制展开，系统讲解 DOM 构建、CSSOM 解析、重排与重绘原理，以及关键渲染路径优化方法。内容涵盖事件循环机制、异步任务调度、资源加载优化、代码拆分与懒加载等性能优化策略。通过真实前端项目案例，帮助开发者理解浏览器底层工作原理，并掌握提升网页加载速度与交互体验的实用技巧。

2026.03.06

Rust内存安全机制与所有权模型深度实践

本专题围绕 Rust 语言核心特性展开，深入讲解所有权机制、借用规则、生命周期管理以及智能指针等关键概念。通过系统级开发案例，分析内存安全保障原理与零成本抽象优势，并结合并发场景讲解 Send 与 Sync 特性实现机制。帮助开发者真正理解 Rust 的设计哲学，掌握在高性能与安全性并重场景中的工程实践能力。

223

2026.03.05

PHP高性能API设计与Laravel服务架构实践

本专题围绕 PHP 在现代 Web 后端开发中的高性能实践展开，重点讲解基于 Laravel 框架构建可扩展 API 服务的核心方法。内容涵盖路由与中间件机制、服务容器与依赖注入、接口版本管理、缓存策略设计以及队列异步处理方案。同时结合高并发场景，深入分析性能瓶颈定位与优化思路，帮助开发者构建稳定、高效、易维护的 PHP 后端服务体系。

458

2026.03.04

AI安装教程大全

2026最全AI工具安装教程专题：包含各版本AI绘图、AI视频、智能办公软件的本地化部署手册。全篇零基础友好，附带最新模型下载地址、一键安装脚本及常见报错修复方案。每日更新，收藏这一篇就够了，让AI安装不再报错！

169

2026.03.04

Swift iOS架构设计与MVVM模式实战

本专题聚焦 Swift 在 iOS 应用架构设计中的实践，系统讲解 MVVM 模式的核心思想、数据绑定机制、模块拆分策略以及组件化开发方法。内容涵盖网络层封装、状态管理、依赖注入与性能优化技巧。通过完整项目案例，帮助开发者构建结构清晰、可维护性强的 iOS 应用架构体系。

246

2026.03.03

C++高性能网络编程与Reactor模型实践

本专题围绕 C++ 在高性能网络服务开发中的应用展开，深入讲解 Socket 编程、多路复用机制、Reactor 模型设计原理以及线程池协作策略。内容涵盖 epoll 实现机制、内存管理优化、连接管理策略与高并发场景下的性能调优方法。通过构建高并发网络服务器实战案例，帮助开发者掌握 C++ 在底层系统与网络通信领域的核心技术。

2026.03.03

热门下载

网站特效

网站源码

网站素材

前端模板