一文詳解Java中的finalize()方法
前言
Java的finalize()方法是Object類定義的一個特殊方法，主要用于在對象被垃圾回收器回收之前執(zhí)行一些清理工作。下面我將從基本概念、工作原理、使用場景、注意事項以及示例代碼等方面詳細解釋這個方法。
基本概念
finalize()方法是Java中Object類的一個protected方法，每個Java類都隱式繼承了這個方法。它的基本語法如下：
protected void finalize() throws Throwable {
// 清理資源的代碼
}
在Object類中，finalize()方法的默認實現(xiàn)是空的，即不做任何事情。子類可以重寫這個方法來提供自己的清理邏輯。
工作原理
當垃圾回收器(GC)確定一個對象不再被任何引用指向時，它會被標記為可回收對象。在真正回收這個對象的內(nèi)存之前，垃圾回收器會調(diào)用該對象的finalize()方法。這個過程可以簡單描述為：
- 對象不再被任何引用指向，成為"不可達"狀態(tài)
- 垃圾回收器標記該對象為可回收
- 在回收前，垃圾回收器調(diào)用對象的
finalize()方法 finalize()方法執(zhí)行完畢后，對象被真正回收
需要強調(diào)的是，finalize()方法的調(diào)用時機是不確定的，它取決于垃圾回收器的實現(xiàn)和調(diào)度策略。垃圾回收器可能在任何時候決定調(diào)用finalize()方法，也可能永遠不會調(diào)用它。
主要用途
1. 資源釋放
這是finalize()方法最常見的用途。當對象持有一些外部資源（如文件句柄、數(shù)據(jù)庫連接等）時，可以在finalize()方法中釋放這些資源，以避免資源泄漏。
示例：
public class ResourceHolder {
private File file;
public ResourceHolder(String fileName) {
try {
file = new File(fileName); // 打開文件進行操作
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
protected void finalize() throws Throwable {
try {
if (file != null) {
file.close(); // 在對象被回收前關(guān)閉文件
}
} finally {
super.finalize();
}
}
}
在這個例子中，ResourceHolder類持有一個文件對象。在finalize()方法中，我們檢查文件是否不為空，并在對象被回收前關(guān)閉文件，以釋放資源。
2. 對象狀態(tài)重置
可以在finalize()方法中重置對象的狀態(tài)，使其可以被再次使用。這對于對象池或緩存對象等場景非常有用，可以避免頻繁地創(chuàng)建和銷毀對象，提高程序的性能和效率。
示例：
public class CacheObject {
private int[] cache;
public CacheObject(int size) {
cache = new int[size]; // 初始化緩存數(shù)據(jù)
}
@Override
protected void finalize() throws Throwable {
// 清理緩存數(shù)據(jù)
for (int i = 0; i < cache.length; i++) {
cache[i] = 0;
}
cache = null;
super.finalize();
}
}
在這個例子中，CacheObject類持有一個整數(shù)數(shù)組作為緩存。在finalize()方法中，我們遍歷緩存數(shù)組并將每個元素設(shè)置為0，然后將緩存數(shù)組設(shè)置為null，以完成清理工作。
3. 對象的自我清理
某些對象在被銷毀之前需要進行一些特定的清理操作，例如清理內(nèi)部緩存、重置對象狀態(tài)等。finalize()方法可以用于實現(xiàn)這些自我清理邏輯。
示例：
class SelfCleaningObject {
private boolean isCleaned;
public void clean() {
isCleaned = true;
}
@Override
protected void finalize() throws Throwable {
if (!isCleaned) {
// 進行自我清理操作
System.out.println("Performing self-cleaning.");
isCleaned = true;
}
super.finalize();
}
}
在這個例子中，SelfCleaningObject類有一個isCleaned標志，用于表示對象是否已經(jīng)被清理。在finalize()方法中，我們檢查isCleaned標志，如果對象未被清理，則執(zhí)行自我清理操作。
使用示例
下面是一個更完整的示例，演示了如何在Java中使用finalize()方法進行資源清理：
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FinalizeExample {
private FileWriter fileWriter;
public FinalizeExample() {
try {
File file = new File("data.txt");
fileWriter = new FileWriter(file);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
protected void finalize() throws Throwable {
try {
if (fileWriter != null) {
fileWriter.close();
System.out.println("File resources cleaned up in finalize().");
}
} finally {
super.finalize();
}
}
public static void main(String[] args) {
FinalizeExample obj = new FinalizeExample();
System.out.println("Object created with hash code: " + obj.hashCode());
obj = null; // 切斷引用，使對象成為垃圾
// 建議JVM執(zhí)行垃圾回收
System.gc();
System.out.println("Requested garbage collection.");
// 等待一段時間，讓垃圾回收有機會執(zhí)行
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("End of program.");
}
}
在這個示例中，我們創(chuàng)建了一個FinalizeExample對象，它持有一個FileWriter實例。在finalize()方法中，我們關(guān)閉了這個FileWriter。在main方法中，我們顯式地斷開對對象的引用，并調(diào)用System.gc()建議JVM執(zhí)行垃圾回收。然后我們等待一段時間，讓垃圾回收有機會執(zhí)行。
注意事項
盡管finalize()方法提供了一種在對象被銷毀之前進行清理的機制，但它存在一些重要的問題和限制，需要特別注意：
1. 調(diào)用不確定性
finalize()方法的調(diào)用時機是不確定的，它取決于垃圾回收器的實現(xiàn)和調(diào)度策略。這意味著：
- 不能保證
finalize()方法一定會被調(diào)用 - 不能保證
finalize()方法何時被調(diào)用 - 不能保證
finalize()方法的執(zhí)行順序
2. 性能開銷
finalize()方法的調(diào)用會帶來一定的性能開銷，因為它需要在垃圾回收器的工作線程中執(zhí)行。如果finalize()方法中包含大量的計算或I/O操作，可能會影響垃圾回收器的性能，甚至導致系統(tǒng)的性能下降。
3. 異常處理
finalize()方法中可能會拋出異常，但這些異常會被忽略，不會影響垃圾回收器的正常工作。因此，在finalize()方法中應該避免拋出異常，或者在拋出異常時進行適當?shù)奶幚怼?/p>
4. 對象復活
finalize()方法中有一個特殊的特性：它可以在方法內(nèi)部創(chuàng)建對該對象的引用，從而使對象重新變?yōu)?quot;可達"狀態(tài)。這被稱為"對象復活"。這種特性可能導致對象在垃圾回收后再次存活，從而延長對象的壽命，并可能導致一些難以預測的問題。
示例：
public class FinalizeResurrection {
public static FinalizeResurrection resurrectedObject = null;
@Override
protected void finalize() throws Throwable {
super.finalize();
resurrectedObject = this; // 使對象復活
}
public static void main(String[] args) throws InterruptedException {
FinalizeResurrection obj = new FinalizeResurrection();
obj = null; // 切斷引用
System.gc(); // 建議垃圾回收
// 等待finalize()方法執(zhí)行
Thread.sleep(1000);
if (resurrectedObject != null) {
System.out.println("Object has been resurrected!");
} else {
System.out.println("Object has not been resurrected.");
}
resurrectedObject = null; // 再次切斷引用
System.gc(); // 再次建議垃圾回收
Thread.sleep(1000);
if (resurrectedObject == null) {
System.out.println("Object is finally garbage collected.");
}
}
}
在這個例子中，FinalizeResurrection類在finalize()方法中將自己賦值給一個靜態(tài)變量，從而使對象"復活"。第一次垃圾回收后，對象會復活；第二次垃圾回收后，對象才會真正被回收。
5. 并發(fā)問題
finalize()方法是在垃圾回收器線程中調(diào)用的，而不是在創(chuàng)建對象的線程中調(diào)用。這可能導致一些并發(fā)問題，特別是在對象狀態(tài)依賴于創(chuàng)建線程上下文的情況下。
6. 內(nèi)存泄漏風險
由于finalize()方法的調(diào)用是不確定的，過度依賴finalize()方法可能會導致內(nèi)存泄漏。例如，如果在finalize()方法中創(chuàng)建了新的對象，并且這些對象沒有被正確引用，那么它們將不會被垃圾回收，從而導致內(nèi)存泄漏。
示例：
public class MemoryLeakExample {
private static final List<MemoryLeakExample> instances = new ArrayList<>();
public MemoryLeakExample() {
instances.add(this);
}
@Override
protected void finalize() throws Throwable {
instances.remove(this);
}
}
在這個例子中，MemoryLeakExample類的每個實例都會被添加到一個靜態(tài)列表中。在finalize()方法中，我們從列表中刪除了當前對象。然而，由于finalize()方法的調(diào)用是不確定的，可能會導致一些對象無法被正確刪除，從而導致內(nèi)存泄漏。
替代方案
由于finalize()方法存在上述問題和限制，Java社區(qū)推薦使用其他機制來管理資源釋放和對象清理。以下是一些更好的替代方案：
1. try-with-resources語句
Java 7及更高版本引入了try-with-resources語句，它可以自動關(guān)閉實現(xiàn)了AutoCloseable接口的資源，而不需要顯式調(diào)用finalize()方法。
示例：
public class TryWithResourcesExample {
public static void main(String[] args) {
try (FileWriter fileWriter = new FileWriter("data.txt")) {
fileWriter.write("Hello, World!");
} catch (IOException e) {
e.printStackTrace();
}
// fileWriter會自動關(guān)閉，無需在finalize()中處理
}
}
在這個例子中，FileWriter實現(xiàn)了AutoCloseable接口，因此在try-with-resources塊結(jié)束時，它會自動被關(guān)閉，無需依賴finalize()方法。
2. 顯式資源釋放
對于不適用try-with-resources的資源，可以在代碼中顯式地釋放資源，通常使用try-finally塊來確保資源被釋放。
示例：
public class ExplicitResourceRelease {
public static void main(String[] args) {
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter("data.txt");
fileWriter.write("Hello, World!");
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileWriter != null) {
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
在這個例子中，我們使用try-finally塊確保FileWriter被正確關(guān)閉，而不依賴垃圾回收機制。
3. 對象池模式
對于需要重用的對象，可以使用對象池模式，而不是依賴finalize()方法進行對象狀態(tài)重置。
示例：
public class ObjectPoolExample {
private static final List<PoolableObject> pool = new ArrayList<>();
public static PoolableObject acquire() {
if (!pool.isEmpty()) {
return pool.remove(0);
}
return new PoolableObject();
}
public static void release(PoolableObject obj) {
obj.reset();
pool.add(obj);
}
}
class PoolableObject {
// 對象狀態(tài)
private String state;
public void use(String newState) {
this.state = newState;
}
public void reset() {
this.state = null;
}
}
在這個例子中，我們創(chuàng)建了一個對象池，對象在使用后會被重置并放回池中，而不是依賴垃圾回收機制。
現(xiàn)代Java中的地位
隨著Java語言的發(fā)展，finalize()方法的重要性已經(jīng)大大降低。Java 9中引入了java.lang.ref.Cleaner類作為finalize()方法的替代方案，它提供了更可靠和更可控的資源清理機制。Java 14中甚至計劃移除finalize()方法，因為它被認為是Java語言中的一個設(shè)計缺陷。
現(xiàn)代Java編程中，除非有特殊需求，否則不建議使用finalize()方法。更好的做法是：
- 使用try-with-resources語句管理可關(guān)閉資源
- 使用try-finally塊確保資源被釋放
- 對于對象池等場景，使用顯式的對象重置方法
附：java里final、finally、finalize的區(qū)別
final :java 關(guān)鍵字。被final修飾的變量不可進行值更改，必須在定義時一并初始化。如final int i=1，則下面對i只能使用，而不能進行更改如i++,更改必定會報錯。同理，final修飾方法時，則子類不能對該方法進行重寫；被final修飾的類不允許繼承。所以，一個類不能不同被abstract和final修飾。（實操驗證見下圖）
finally：多見與java的try..catch..finally塊，只有try語句塊正常執(zhí)行（不做退出線程，死機等情況的考慮），那么無論catch語句塊是否執(zhí)行 ，finally語句塊都會執(zhí)行，且最終整個try..finally代碼塊返回情況以finally中的return結(jié)果為準（見下圖）。所以在代碼邏輯中有需要無論發(fā)生什么都必須執(zhí)行的代碼，就可以放在finally塊中。
finalize：類的finalize()方法，可以告訴垃圾回收器應該執(zhí)行的操作，該方法從Object類繼承而來。在從堆中永久刪除對象之前，垃圾回收器調(diào)用該對象的finalize()方法。下圖是Object類中的finalize 方法。
總結(jié)
Java的finalize()方法是一個特殊的方法，它在對象被垃圾回收器回收之前被調(diào)用，主要用于執(zhí)行一些清理工作。雖然它提供了一種在對象銷毀前進行資源釋放和狀態(tài)重置的機制，但由于其調(diào)用不確定性、性能開銷和潛在的并發(fā)問題，現(xiàn)代Java編程中已經(jīng)不推薦使用它。
更好的做法是使用try-with-resources語句、try-finally塊和顯式的資源管理代碼來確保資源被正確釋放。對于對象池等場景，應該使用顯式的對象重置方法，而不是依賴finalize()方法。隨著Java語言的發(fā)展，finalize()方法的重要性已經(jīng)大大降低，未來可能會被完全移除。
到此這篇關(guān)于Java中finalize()方法的文章就介紹到這了,更多相關(guān)Java中finalize()方法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
Spring Boot 緩存優(yōu)化Redis 實戰(zhàn)指南
本文介紹了如何在SpringBoot項目中集成Redis緩存,以優(yōu)化性能并提高用戶體驗,通過實戰(zhàn),讀者可以快速掌握Redis緩存的集成方法,并在實際項目中應用,解決數(shù)據(jù)量大的性能瓶頸,感興趣的朋友跟隨小編一起看看吧2026-03-03
這篇文章主要介紹了java 導入Excel思路及代碼示例，簡要分析了設(shè)計思路，然后分享了實例代碼，具有一定參考價值，需要的朋友可以了解下。2017-11-11
JAVA8 List<List<Integer>> list中再裝一個list轉(zhuǎn)成一個list操
這篇文章主要介紹了JAVA8 List<List<Integer>> list中再裝一個list轉(zhuǎn)成一個list操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-08-08
SpringCloud應用idea實現(xiàn)可相互調(diào)用的多模塊程序詳解
IDEA 全稱 IntelliJ IDEA，是java編程語言的集成開發(fā)環(huán)境。IntelliJ在業(yè)界被公認為最好的Java開發(fā)工具，尤其在智能代碼助手、代碼自動提示、重構(gòu)、JavaEE支持、各類版本工具(git、svn等)、JUnit、CVS整合、代碼分析、 創(chuàng)新的GUI設(shè)計等方面的功能可以說是超常的2022-07-07
SpringBoot整合Redis實現(xiàn)訂單超時自動刪除功能
在電商、外賣等場景中,訂單超時未支付是常見業(yè)務(wù)場景,傳統(tǒng)方案通過定時任務(wù)輪詢數(shù)據(jù)庫,但存在??延遲高??、??數(shù)據(jù)庫壓力大等問題,Redis的??過期鍵自動刪除機制??,可完美解決這一痛點,所以本文給大家介紹了SpringBoot整合Redis實現(xiàn)訂單超時自動刪除2025-07-07
這篇文章主要介紹了解決springboot整合druid遇到的坑，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-08-08
在Spring框架中,可以使用攔截器（Interceptor）來監(jiān)聽每個控制器（Controller）的請求,并記錄請求者的IP地址,這篇文章主要介紹了springboot如何獲取請求者的ip地址,需要的朋友可以參考下2024-07-07
SpringMvc3+extjs4實現(xiàn)上傳與下載功能
這篇文章主要為大家詳細介紹了SpringMvc3+extjs4實現(xiàn)上傳與下載功能，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-06-06
JAVA包裝類及自動封包解包實例代碼，需要的朋友可以參考一下2013-03-03
這篇文章主要介紹了關(guān)于自定義過濾器獲取不到session問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-01-01