深入分析Object.finalize方法的实现原理

合集下载

对象的 finalize

对象的 finalize

对象的 finalize对象的 finalize 是 Java 中一个重要的方法,它在对象被垃圾回收器回收之前被调用。

finalize 方法可以被子类重写,以实现对象在被回收前进行一些清理工作,比如关闭文件、释放资源等。

在Java 中,垃圾回收器是自动管理内存的,当一个对象不再被引用时,垃圾回收器会自动将其回收。

但是,在回收对象之前,垃圾回收器会先调用对象的 finalize 方法,以便让对象进行一些清理工作。

如果对象没有重写 finalize 方法,那么垃圾回收器会直接回收对象,不会进行任何清理工作。

在 Java 中,finalize 方法有一些限制和注意事项。

首先,finalize 方法不保证一定会被调用,因为垃圾回收器的行为是不确定的。

其次,finalize 方法只会被调用一次,因此不能依赖 finalize 方法来进行重要的清理工作。

最后,finalize 方法的执行会影响垃圾回收的效率,因此应该尽量避免在 finalize 方法中进行复杂的操作。

为了避免 finalize 方法的限制和问题,Java 推荐使用 try-with-resources 语句来管理资源。

try-with-resources 语句可以自动关闭资源,无需手动调用 close 方法或者实现 finalize 方法。

例如:```try (FileInputStream fis = new FileInputStream("file.txt")) {// 使用 fis 读取文件} catch (IOException e) {// 处理异常}```在上面的代码中,try-with-resources 语句会自动关闭FileInputStream 对象,无需手动调用 close 方法。

如果发生异常,也会自动关闭 FileInputStream 对象。

总之,对象的 finalize 方法是 Java 中一个重要的方法,它可以让对象在被回收前进行一些清理工作。

finalize方法

finalize方法

finalize方法在Java编程语言中,finalize方法是一种特殊的方法,它用于在对象被垃圾收集器回收之前执行一些必要的清理操作。

在本文中,我们将深入探讨finalize方法的作用、用法和一些需要注意的地方。

首先,让我们来看看finalize方法的作用。

finalize方法主要用于在对象即将被销毁时执行一些清理工作,比如关闭文件或者释放资源。

这对于一些需要手动释放资源的对象来说非常重要,因为Java的垃圾收集器并不保证对象被销毁时会立即释放相关资源。

因此,通过在finalize方法中进行资源释放操作,可以确保资源得到及时释放,避免出现内存泄漏等问题。

接下来,让我们来看看如何使用finalize方法。

要使用finalize方法,只需在对象的类中重写该方法,并在其中编写清理操作的代码即可。

需要注意的是,finalize 方法是由垃圾收集器在销毁对象时自动调用的,因此我们无法直接调用该方法,也不能保证该方法会被及时调用。

因此,我们不能将finalize方法用于一些必须要及时释放资源的场景,比如数据库连接的关闭等操作。

此外,还有一些需要注意的地方。

首先,由于finalize方法的调用时机是不确定的,因此在编写finalize方法时,需要确保其中的代码不会影响对象的状态。

其次,由于finalize方法的调用是由垃圾收集器自动触发的,因此不能保证该方法会被及时调用,所以在编写程序时,不应该依赖于finalize方法来进行重要的清理操作。

总之,finalize方法是一种在对象被销毁前执行清理操作的机制,它可以用于释放资源、关闭文件等操作。

然而,在实际编程中,我们应该尽量避免使用finalize 方法,而是采用其他更可靠的资源管理方式,比如使用try-with-resources语句、手动调用close方法等。

这样可以更好地确保资源的及时释放,避免出现一些不可预料的问题。

总结一下,finalize方法虽然在某些情况下能够发挥作用,但在实际编程中应该尽量避免使用。

finalize机制

finalize机制

finalize机制【最新版】目录1.Finalize 机制的概述2.Finalize 机制的作用3.Finalize 机制的实现原理4.Finalize 机制的实例应用5.Finalize 机制的优缺点正文【1.Finalize 机制的概述】Finalize 机制,是 Java 语言中一种用于确保对象在垃圾回收之前执行一定操作的机制。

它允许对象在特定的时刻进行一些必要的清理工作,以确保对象被正确地回收。

【2.Finalize 机制的作用】Finalize 机制的主要作用有两点:(1)对象的自我清理:在垃圾回收之前,对象可以利用 Finalize 机制执行一些清理工作,如关闭文件、断开网络连接等。

这样可以确保对象被正确地回收,避免资源泄露。

(2)延长对象的生存时间:如果对象在 Finalize 方法中执行了一些操作,那么垃圾回收器会考虑这些操作,从而延长对象的生存时间。

这对于某些需要在特定时刻执行操作的对象非常有用。

【3.Finalize 机制的实现原理】Finalize 机制的实现原理主要基于 Java 的垃圾回收机制。

当垃圾回收器决定回收一个对象时,它会首先调用对象的 Finalize 方法。

如果对象实现了 Finalize 方法,那么它会在方法中执行相应的清理操作。

然后,垃圾回收器会再次检查对象,如果对象已经完成了清理工作,那么它就会被回收。

否则,对象会被移至下一次垃圾回收。

【4.Finalize 机制的实例应用】以下是一个 Finalize 机制的实例应用:```javaclass Example {private File file;public Example(String fileName) {file = new File(fileName);}public void write(String content) {try {file.write(content);} catch (IOException e) {e.printStackTrace();}}protected void finalize() {try {file.close();} catch (IOException e) {e.printStackTrace();}}}```在这个例子中,我们创建了一个名为 Example 的类。

java的finalize方法

java的finalize方法

java的finalize方法Java是一种非常流行的编程语言,它具有很多独特的功能和特性。

其中之一就是finalize方法。

在本文中,我们将深入研究Java中的finalize方法,以了解它的作用及如何使用它。

一、概述finalize是Java中的一个方法,它在对象被垃圾回收器回收之前被调用。

finalize方法是Object类中的一个方法,所有Java对象都可以使用它。

二、作用finalize方法的作用是在对象被销毁之前进行一些必要的清理工作。

这些工作可以包括释放资源(如文件或数据库连接)、关闭网络连接、清除缓存等等。

finalize方法可以确保这些清理工作在对象被销毁之前完成,从而避免资源泄漏或其他问题。

三、用法要使用finalize方法,我们需要将其重写为我们要清理的类中。

例如:class MyClass {// some code hereprotected void finalize() throws Throwable {// cleanup code here}}在上面的示例中,我们重写了finalize方法,然后在其中添加了我们要执行的清理代码。

我们要确保我们的清理代码是安全的,并且不会引发任何异常,否则可能会出现意外的结果。

四、限制虽然finalize方法可以帮助我们管理对象中的资源,但有一些限制需要考虑。

第一,finalize方法是Java中唯一的终止方法。

只有在Java虚拟机(JVM)停止时,finalize方法才会被调用。

由于JVM停止的时间不可预测,因此我们不能保证finalize方法将始终被调用。

第二,finalize方法会影响垃圾回收器的性能。

每个对象在被销毁前都会调用它的finalize方法。

如果有大量对象需要进行清理工作,这可能导致垃圾回收器的性能下降。

第三,finalize方法不能确保资源释放。

虽然finalize方法在对象被销毁之前会被调用,但它不能保证所有资源都已被清理。

finalize()方法

finalize()方法

当垃圾回收器将要释放无用对象的内存时,先调用该对象的finalize()方法。

如果在程序终止之前垃圾回收器始终没有执行垃圾回收操作,那么垃圾回收器将始终不会调用无用对象的finalize()方法。

在Java的Object祖先类中提供了protected类型的finalize()方法,因此任何Java类都可以覆盖finalize()方法,在这个方法中进行释放对象所占的相关资源的操作。

Java虚拟机的垃圾回收操作对程序完全是透明的,因此程序无法预料某个无用对象的finalize()方法何时被调用。

另外,除非垃圾回收器认为程序需要额外的内存,否则它不会试图释放无用对象占用的内存。

换句话说,以下情况是完全可能的:一个程序只占用了少量内存,没有造成严重的内存需求,于是垃圾回收器没有释放那些无用对象占用的内存,因此这些对象的finalize()方法还没有被调用,程序就终止了。

程序即使显式调用System.gc()或Runtime.gc()方法,也不能保证垃圾回收操作一定执行,因此不能保证无用对象的finalize()方法一定被调用。

11.4.4 对象的finalize()方法的特点对象的finalize()方法具有以下特点:垃圾回收器是否会执行该方法及何时执行该方法,都是不确定的。

finalize()方法有可能使对象复活,使它恢复到可触及状态。

垃圾回收器在执行finalize()方法时,如果出现异常,垃圾回收器不会报告异常,程序继续正常运行。

下面结合一个具体的例子来解释finalize()方法的特点。

例程11-13的Ghost类是一个带实例缓存的不可变类,它的finalize()方法能够把当前实例重新加入到实例缓存ghosts中。

例程11-13 Ghost.javaview plaincopy to clipboardprint?01.import java.util.Map;02.03.import java.util.HashMap;04.05.public class Ghost {06.07. private static final Map<String, Ghost> ghosts = new HashMap<String, Ghost>();08.09. private final String name;10.11. public Ghost(String name) {12.13. = name;14.15. }16.17. public String getName() {18. return name;19. }20.21. public static Ghost getInstance(String name) {22.23. Ghost ghost = ghosts.get(name);24.25. if (ghost == null) {26.27. ghost = new Ghost(name);28.29. ghosts.put(name, ghost);30.31. }32.33. return ghost;34.35. }36.37. public static void removeInstance(String name) {38.39. ghosts.remove(name);40.41. }42.43. protected void finalize() throws Throwable {44.45. ghosts.put(name, this);46.47. System.out.println("execute finalize");48.49. // throw new Exception("Just Test");50.51. }52.53. public static void main(String args[]) throws Exception {54.55. Ghost ghost = Ghost.getInstance("IAmBack"); // ①56.57. System.out.println(ghost); // ②58.59. String name = ghost.getName(); // ③60.61. ghost = null; // ④62.63. Ghost.removeInstance(name); // ⑤64.65. System.gc(); // ⑥66.67. // 把CPU让给垃圾回收线程68.69. Thread.sleep(3000); // ⑦70.71. ghost = Ghost.getInstance("IAmBack"); // ⑧72.73. System.out.println(ghost); // ⑨74.75. }76.77.}import java.util.Map;import java.util.HashMap;public class Ghost {private static final Map<String, Ghost> ghosts = new HashMap<String, Ghost>();private final String name;public Ghost(String name) { = name;}public String getName() {return name;}public static Ghost getInstance(String name) {Ghost ghost = ghosts.get(name);if (ghost == null) {ghost = new Ghost(name);ghosts.put(name, ghost);}return ghost;}public static void removeInstance(String name) { ghosts.remove(name);}protected void finalize() throws Throwable {ghosts.put(name, this);System.out.println("execute finalize");// throw new Exception("Just Test");}public static void main(String args[]) throws Exception { Ghost ghost = Ghost.getInstance("IAmBack"); // ①System.out.println(ghost); // ②String name = ghost.getName(); // ③ghost = null; // ④Ghost.removeInstance(name); // ⑤System.gc(); // ⑥// 把CPU让给垃圾回收线程Thread.sleep(3000); // ⑦ghost = Ghost.getInstance("IAmBack"); // ⑧System.out.println(ghost); // ⑨}}运行以上Ghost类的main()方法,一种可能的打印结果为:Ghost@3179c3execute finalizeGhost@3179c3以上程序创建了3个对象:1个Ghost对象、1个常量字符串“IAmBack”及1个HashMap 对象。

深入分析Java中finalize方法的作用和底层原理

深入分析Java中finalize方法的作用和底层原理

深入分析Java中finalize方法的作用和底层原理(英文):In Java, the finalize method is a special method that can be overridden by classes to define cleanup actions when an object is about to be garbage collected. It's a part of Java's garbage collection mechanism, allowing objects to perform any necessary cleanup before they are destroyed.Purpose of finalize Method:The main purpose of the finalize method is to provide a mechanism for an object to perform any last-minute cleanup operations, such as closing open files, releasing resources, or performing any other actions necessary before the object is reclaimed by the garbage collector. However, it's important to note that relying solely on finalize for resource management is not recommended due to its non-deterministic nature and potential performance issues.Underlying Principles:1.Garbage Collection: Java uses a garbage collector to automatically reclaimmemory occupied by objects that are no longer referenced. When an objectbecomes unreachable (i.e., there are no more references to it), it becomeseligible for garbage collection.2.Finalization Queue: When the garbage collector identifies an object asunreachable, it places the object on a special queue called the finalizationqueue. The finalizer thread then runs the finalize method for each object inthis queue.3.Non-Deterministic Execution: It's important to note that the execution ofthe finalize method is non-deterministic. The garbage collector runs at itsown discretion, and there's no guarantee as to when or even ifthe finalize method will be called.4.Deprecation: As of Java 9, the finalize method has been deprecated due toits unreliability and potential for causing problems. Instead, Javarecommends using try-with-resources statements or cleaners for resourcemanagement.深入分析Java中finalize方法的作用和底层原理(中文介绍)在Java中,finalize方法是一个特殊的方法,可以被类重写以定义当对象即将被垃圾回收时的清理操作。

object类的九个方法 -回复

object类的九个方法-回复Object类是Java语言中的根类,它包含了一些基本的方法,这些方法可以在所有的Java类中被继承和使用。

下面将逐一介绍Object类的九个方法。

1. equals(Object obj)方法:该方法用于判断当前对象是否与另一个对象相等。

默认情况下,该方法直接比较两个对象的引用是否相同,即判断两个对象是否是同一个对象。

如果需要比较对象的内容是否相等,需要在子类中重写该方法。

2. hashCode()方法:该方法用于计算对象的哈希码值,并返回一个整数。

哈希码值在哈希表中用于快速定位对象,因此该方法的实现必须与equals 方法保持一致性,即如果两个对象相等,它们的哈希码值必须相等。

3. toString()方法:该方法将当前对象转换为字符串并返回。

默认情况下,该方法返回对象的类名和无符号十六进制表示的哈希码值。

可以在子类中重写该方法,以便返回更具有可读性的字符串表示。

4. getClass()方法:该方法返回当前对象的运行时类。

在Java中,对象的类是在运行时确定的,因此可以使用getClass方法获取对象的实际类型。

5. finalize()方法:该方法在对象被垃圾回收器回收之前被调用。

默认情况下,该方法不执行任何操作,可以在子类中重写该方法来实现对资源的释放或清理操作。

6. clone()方法:该方法用于创建并返回当前对象的一个副本。

要实现克隆功能,需要在子类中重写该方法,并使用深度克隆或浅度克隆的方式复制对象的字段。

7. notify()方法和notifyAll()方法:这两个方法用于实现线程之间的通信。

当一个线程在等待对象锁时,可以使用notify方法唤醒一个正在等待的线程,或使用notifyAll方法唤醒所有正在等待的线程。

8. wait()方法:该方法用于使当前线程进入等待状态,直到其他线程调用该对象的notify()或notifyAll()方法,或指定的等待时间到期。

finalize()方法详解

finalize()⽅法详解finalize()⽅法详解,前⾔,finalize()是Object的protected⽅法,⼦类可以覆盖该⽅法以实现资源清理⼯作,GC在回收对象之前调⽤该⽅法。

finalize的作⽤(1)finalize()与C++中的析构函数不是对应的。

C++中的析构函数调⽤的时机是确定的(对象离开作⽤域或delete掉),但Java中的finalize的调⽤具有不确定性(2)不建议⽤finalize⽅法完成“⾮内存资源”的清理⼯作,但建议⽤于:①清理本地对象(通过JNI 创建的对象);②作为确保某些⾮内存资源(如Socket、⽂件等)释放的⼀个补充:在finalize⽅法中显式调⽤其他资源释放⽅法。

其原因可见下⽂[finalize的问题finalize的问题(1)⼀些与finalize相关的⽅法,由于⼀些致命的缺陷,已经被废弃了,如System.runFinalizersOnExit()⽅法、Runtime.runFinalizersOnExit()⽅法(2)System.gc()与System.runFinalization()⽅法增加了finalize⽅法执⾏的机会,但不可盲⽬依赖它们(3)Java语⾔规范并不保证finalize⽅法会被及时地执⾏、⽽且根本不会保证它们会被执⾏(4)finalize⽅法可能会带来性能问题。

因为JVM通常在单独的低优先级线程中完成finalize的执⾏(5)对象再⽣问题:finalize⽅法中,可将待回收对象赋值给GC Roots可达的对象引⽤,从⽽达到对象再⽣的⽬的(6)finalize⽅法⾄多由GC执⾏⼀次(⽤户当然可以⼿动调⽤对象的finalize⽅法,但并不影响GC对finalize的⾏为)finalize的执⾏过程(⽣命周期)(1) ⾸先,⼤致描述⼀下finalize流程:当对象变成(GC Roots)不可达时,GC会判断该对象是否覆盖了finalize⽅法,若未覆盖,则直接将其回收。

finalize方法

finalize方法finalize方法是Java语言中一种特殊的方法,它定义在ng.Object类中,属于垃圾回收(Garbage Collection,GC)的一部分,并且其他所有的类都是它的子类。

finalize方法的作用是在一个对象即将被垃圾回收时,会被调用一次。

我们可以在finalize方法中释放资源,如文件句柄,数据库连接等。

finalize方法是被垃圾回收器调用的,并且每个对象只会被调用一次,因此,不要想着在finalize方法里面完成一些清除任务。

finalize方法是在垃圾回收器去执行它的时候才会被调用,而且不确定finalize方法什么时候会被调用,所以finalize方法属于不可预测的,因此,在finalize方法中最好不要包含任何业务逻辑,以免在finalize方法中调用的类的属性它被回收了,而造成运行错误。

finalize方法的另一个作用是当一个类需要释放资源时,可以通过调用finalize方法来释放资源。

例如,如果某个类中有一个构造函数,它需要读取文件,我们可以在finalize方法中关闭该文件。

finalize方法只有一个参数,即Throwable(可抛出的异常),如果finalize方法有异常抛出,异常会被忽略。

finalize方法继承自Object,但是只有空实现,大多数情况我们应该重写finalize方法(手动释放资源),而不应该强制调用它。

finalize方法的另一个重要特性是,它是一种非常低效的方法,一般情况下它不应该用于即时释放资源,它只适用于一种方式:在垃圾回收发生的时候,允许程序员提供一些补救措施(如手动释放资源)。

因此,finalize方法不是一种常用的方法,它最好用于释放资源,但是它是不可预测的,我们不能够通过finalize方法来处理业务逻辑。

同时,由于finalize方法的低效性,它不应该用来立即释放资源。

所以,我们在处理资源释放问题时,应该尽量避免使用finalize方法。

JavaGC机制和对象Finalize方法的一点总结

JavaGC机制和对象Finalize⽅法的⼀点总结GC是什么? 为什么要有GC?GC是垃圾收集的意思(Garbage Collection),内存处理是编程⼈员容易出现问题的地⽅,忘记或者错误的内存回收会导致程序或系统的不稳定甚⾄崩溃,Java提供的GC功能可以⾃动监测对象是否超过作⽤域从⽽达到⾃动回收内存的⽬的。

有向图垃圾回收机制.NET的垃圾回收采⽤引⽤计数,java的垃圾回收机制采取的是有向图的⽅式来实现,具体的说,java程序中的每个线程对象就可以看作是⼀个有向图的起点,有向边从栈中的引⽤者指向堆中的引⽤对象。

在这个有向图中,如果⼀个对象和根节点之间是可达的,那么这个对象就是有效的,反之,这个对象就是可以被回收的。

采取这样⼀种机制的优点是可以有效的避免循环引⽤。

当程序员创建对象时,GC就开始监控这个对象的地址、⼤⼩以及使⽤情况。

通过有向图机制确定哪些对象是"可达的",哪些对象是"不可达的".当GC确定⼀些对象为"不可达"时,GC就有责任回收这些内存空间。

GC在JVM中通常是由⼀个或⼀组线程来实现的,它本⾝也和⽤户程序⼀样占⽤heap空间,运⾏时也占⽤CPU.当GC进程运⾏时,应⽤程序停⽌运⾏。

为了防⽌finalize函数抛出的异常影响到垃圾回收线程的运作,垃圾回收线程会在调⽤每⼀个finalize函数时进⾏try catch,如果捕获到异常,就直接丢弃,然后接着处理下⼀个失效对象的finalize函数。

所以finalize函数内⼀般需要⾃⼰处理抛出的异常,防⽌发⽣未处理异常情况。

当GC运⾏时间较长时,⽤户能够感到 Java程序的停顿,另外⼀⽅⾯,如果GC运⾏时间太短,则可能对象回收率太低,这意味着还有很多应该回收的对象没有被回收,仍然占⽤⼤量内存。

因此⼀种折中的⽅案就是每次GC处理⼀定⽐例的对象,分成多次进⾏,这就叫增量式GC。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

“物有本末,事有始终。

知其先后,则近道矣”
finalize
如果类中重写了finalize方法,当该类对象被回收时,finalize方法有可能会被触发,下面通过一个例子说明finalize方法对垃圾回收有什么影响。

1 2 3 4 5 6 7 8 9
10
11
12
13
14
15 public class FinalizeCase {
private static Block holder = null;
public static void main(String[] args) throws Exception { holder = new Block();
holder = null;
System.gc();
//System.in.read();
}
static class Block {
byte[] _200M = new byte[200*1024*1024];
}
}
Block类中声明一个占用内存200M的数组,是为了方便看出来gc之后是否回收了Block 对象,执行完的gc日志如下:
从gc日志中可以看出来,执行完System.gc()之后,Block对象被如期的回收了,如果在Block类中重写了finalize方法,会是一样的结果么?
1 2 3 4 5 6 7 static class Block {
byte[] _200M = new byte[200*1024*1024];
@Override
protected void finalize() throws Throwable {
System.out.println("invoke finalize");
}
}
执行完成gc日志如下:
和之前的gc日志进行比较,发现finalize方法确实被触发了,但是Block对象还在内存中,并没有被回收,这是为什么?
下面对finalize方法的实现原理进行分析。

finalize实现原理
《JVM源码分析之Java对象的创建过程》一文中分析了Java对象创建的整个过程,代码实现如下:
对象的初始化过程会对has_finalizer_flag和RegisterFinalizersAtInit进行判断,如果类重写了finalize方法,且方法体不为空,则调用register_finalizer函数,继续看register_finalizer函数的实现:
其中Universe::finalizer_register_method()缓存的是jdk中
ng.ref.Finalizer类的register方法,实现如下:
在jvm中通过JavaCalls::call触发register方法,将新建的对象O封装成一个Finalizer对象,并通过add方法添加到Finalizer链表头。

对象O和Finalizer类的静态变量unfinalized有联系,在发生GC时,会被判定为活跃对象,因此不会被回收
FinalizerThread线程
在Finalizer类的静态代码块中会创建一个FinalizerThread类型的守护线程,但是这个线程的优先级比较低,意味着在cpu吃紧的时候可能会抢占不到资源执行。

FinalizerThread线程负责从ReferenceQueue队列中获取Finalizer对象,如果队列中没有元素,则通过wait方法将该线程挂起,等待被唤醒
如果返回了Finalizer对象,执行对象的runFinalizer()方法,其实可以发现:在runFinalizer()方法中主动捕获了异常,即使在执行finalize方法抛出异常时,也没有关系。

通过hasBeenFinalized方法判断该对象是否还在链表中,并将该Finalizer对象从链表中删除,这样下次gc时就可以把原对象给回收掉了,最后调用了native方法invokeFinalizeMethod,其中invokeFinalizeMethod方法最终会找到并执行对象的finalize方法。

ReferenceHandler线程
有个疑问:既然FinalizerThread线程是从ReferenceQueue队列中获取Finalizer对象,那么Finalizer对象是在什么情况下才会被插入到ReferenceQueue队列中?Finalizer的祖父类Reference中定义了ReferenceHandler线程,实现如下:
当pending被设置时,会调用ReferenceQueue的enqueue方法把Finalizer对象插入到ReferenceQueue队列中,接着通过notifyAll方法唤醒FinalizerThread线程执行后续逻辑,实现如下:
pending字段什么时候会被设置?
在GC过程的引用处理阶段,通过oopDesc::atomic_exchange_oop方法把发现的引用列表设置在pending字段所在的地址
Finalizer导致的内存泄漏
平常使用的Socket通信,SocksSocketImpl的父类重写了finalize方法
这么做主要是为了确保在用户忘记手动关闭socket连接的情况下,在该对象被回收时能够自动关闭socket来释放一些资源,但是在开发过程中,真的忘记手动调用了close方法,那么这些socket对象可能会因为FinalizeThread线程迟迟没有执行到这些对象的finalize方法,而导致一直占用某些资源,造成内存泄露。

1。

相关文档
最新文档