快捷導(dǎo)航

java的finalize方法解讀

更新時間：2023年09月28日 09:14:57 作者：weixin_43831204

這篇文章主要介紹了java的finalize方法,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教

我們通常用構(gòu)造器來創(chuàng)建對象，而Finalize正好相反，構(gòu)造方法執(zhí)行對象的初始化操作，finalize方法執(zhí)行對象的銷毀操作.那我們什么時候需要使用finalize方法呢，我們都知道Java里垃圾回收器可以回收對象使用的內(nèi)存空間，但是對象可能會持有很多資源比如Socket、文件句柄等，垃圾收集器無法回收這些資源，因此你需要使用finalize方法幫助GC回收這些資源，比如關(guān)閉打開的文件或者網(wǎng)元資源，刪除臨時文件等.

一個例子

Object類是所有類的父類，如果你去查看java.lang.Object類的源碼，你會發(fā)現(xiàn)里面有個finalize方法，這個方法沒有默認實現(xiàn)，需要子類根據(jù)實際情況重寫這個方法，但是如果不恰當(dāng)使用finalize方法可能會造成很大的負面影響，

比如下面的例子：

public class Finalizer {
    @Override
    protected void finalize() throws Throwable {
    while (true) {
           Thread.yield();
      }
  }
public static void main(String str[]) {
  while (true) {
        for (int i = 0; i < 100000; i++) {
            Finalizer force = new Finalizer();
        }
   }
 }
}

當(dāng)我們運行上述代碼時，可以看到創(chuàng)建大量的Finalizer對象，運行一段時間后一般出現(xiàn)以下兩種結(jié)果：

JVM異常退出并且生成了內(nèi)存鏡像Dump
JVM拋出了一個異常:Out of Memory:GC OverHead limit exceeded.

不管上述兩種情況，JVM都崩潰了，那到底執(zhí)行finalize方法時發(fā)生了什么.Jvm會給每個實現(xiàn)了finalize方法的實例創(chuàng)建一個監(jiān)聽，這個稱為Finalizer，每次調(diào)用對象的finalize方法時，JVM會創(chuàng)建一個 java.lang.ref.Finalizer 對象，這個Finalizer對象會持有這個對象的引用，由于這些對象被Finilizer對象引用了，當(dāng)對象數(shù)量較多時，就會導(dǎo)致Eden區(qū)空間滿了，經(jīng)歷多次youngGC后可能對象就進入到老年代了. java.lang.ref.Finalizer 類繼承自 java.lang.ref.FinalReference ，也是Refence的一種，因此Finalizer類里也有一個引用隊列，這個引用隊列是JVM和垃圾回收器打交道的唯一途徑，當(dāng)垃圾回收器需要回收該對象時，會把該對象放到引用隊列中，這樣java.lang.ref.Finalizer類就可以從隊列中取出該對象，執(zhí)行對象的finalize方法，并清除和該對象的引用關(guān)系.需要注意的是只有finalize方法實現(xiàn)不為空時JVM才會執(zhí)行上述操作，JVM在類的加載過程中會標(biāo)記該類是否為finalize類.

GC怎么處理這些對象呢

當(dāng)老年代空間達到了OldGC條件時，JVM執(zhí)行一次OldGC，當(dāng)OldGC執(zhí)行后JVM檢測到這些對象只被Finalizer對象引用，這些對象會被標(biāo)記成要被清除的對象，GC會把所有的Finalizer對象放入到一個引用隊列： java.lang.ref.Finalizer.ReferenceQueue .

Finalizer對象怎么被清理的呢

JVM默認會創(chuàng)建一個finalizer線程來處理Finalizer對象，如果你去抓取線程堆棧的話可以看到這個線程的堆棧，

如下所示：

"Finalizer" daemon prio=10 tid=0x0962d000 nid=0x4836 runnable [0xafaa8000]
   java.lang.Thread.State: RUNNABLE
        at java.lang.Thread.yield(Native Method)
        at finalizer.finalize(finalizer.java:5)
        at java.lang.ref.Finalizer.invokeFinalizeMethod(Native Method)
        at java.lang.ref.Finalizer.runFinalizer(Finalizer.java:83)
        at java.lang.ref.Finalizer.access$100(Finalizer.java:14)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:160)

這個線程唯一的職責(zé)就是不斷的從 java.lang.ref.Finalizer.ReferenceQueue 隊列中取對象，當(dāng)一個對象進入到隊列中，finalizer線程就執(zhí)行對象的finalize方法并且把對象從隊列中刪除，因此在下一次GC周期中可以看到這個對象和Finalizer對象都被清除了.

大部分場景finalizer線程清理finalizer隊列是比較快的，但是一旦你在finalize方法里執(zhí)行一些耗時的操作，可能導(dǎo)致內(nèi)存無法及時釋放進而導(dǎo)致內(nèi)存溢出的錯誤，在實際場景還是推薦盡量少用finalize方法.

簡單粗暴，一個死循環(huán)去隊列里面拿出Finalizer對象，并執(zhí)行finalize方法，再置空為null，可供垃圾回收

實戰(zhàn)案例

public class Finalizer {
    @Override
    protected void finalize() throws Throwable {
        System.out.println("finalize");
    }
    public static void main(String str[]) throws IOException {
            for (int i = 0; i < 10000; i++) {
                Finalizer force = new Finalizer();
            }
            //讓線程阻塞住,方便分析內(nèi)存使用情況
        System.in.read();
    }
}

執(zhí)行main方法后使用jmap命令查看內(nèi)存使用情況，可以看到 java.lang.ref.Finalizer 和Finalizer的實例都創(chuàng)建了10000個：

$ jmap -histo 8700|head -n 10
 num     #instances         #bytes  class name
----------------------------------------------
   1:           646        3398408  [I
   2:          1851        1511144  [B
   3:          6081         808864  [C
   4:         10175         407000  java.lang.ref.Finalizer
   5:         10000         160000  Finalizer
   6:          4328         103872  java.lang.String
   7:           601          64208  java.lang.Class
   8:           683          40952  [Ljava.lang.Object;
   9:           785          31400  java.util.TreeMap$Entry
  10:           248          14144  [Ljava.lang.String;

接下來使用jmap -histo：live 8700|head -n 10命令強制觸發(fā)一次GC，結(jié)果和前面的分析一致，F(xiàn)inalizer對象都放到引用隊列中，并依次調(diào)用了對象的finalize方法，內(nèi)存中java.lang.ref.Finalizer和Finalizer對象依然存在，不過這一java.lang.ref.Finalizer

不再引用Finalizer對象，下一次GC周期時兩者都屬于垃圾對象：

$ jmap -histo:live 8700|head -n 10
 num     #instances         #bytes  class name
----------------------------------------------
   1:         10175         407000  java.lang.ref.Finalizer
   2:          3043         372608  [C
   3:           605         273624  [B
   4:         10000         160000  Finalizer
   5:          2883          69192  java.lang.String
   6:           601          64208  java.lang.Class
   7:           631          37008  [Ljava.lang.Object;

再觸發(fā)一次jmap -histo：live 8700|head -n 10，可以看到兩者都被回收了：

$ jmap -histo:live 8700|head -n 10
 num     #instances         #bytes  class name
----------------------------------------------
   1:          3059         373224  [C
   2:           498         138064  [B
   3:          2899          69576  java.lang.String
   4:           602          64312  java.lang.Class
   5:           631          37008  [Ljava.lang.Object;
   6:           785          31400  java.util.TreeMap$Entry
   7:           227          11256  [Ljava.lang.String;

我們來總結(jié)一下

finalize對象至少經(jīng)歷兩次GC才能被回收，因為只有在FinalizerThread執(zhí)行完了finalize對象的finalize方法的情況下才有可能被下次GC回收，而有可能期間已經(jīng)經(jīng)歷過多次GC了，但是一直還沒執(zhí)行finalize對象的finalize方法;

CPU資源不足的場景FinalizerThread線程可能因為優(yōu)先級較低而一直沒有執(zhí)行對象的finalize方法，可能導(dǎo)致大部分對象進入到老年代，進而觸發(fā)老年代GC，設(shè)置觸發(fā)Full GC.

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

您可能感興趣的文章: