2. 程式人生 > >詳解Java類的生命周期

詳解Java類的生命周期

阿新 • • 發佈：2017-05-22
字段 view 數據類型 分配內存 lar ati final 並不是 編譯

引言

最近有位細心的朋友在閱讀筆者的文章時，對Java類的生命周期問題有一些疑惑，筆者打開百度搜了一下相關的問題，看到網上的資料很少有把這個問題講明白的，主要是因為目前國內Java方面的教材大多只是告訴你“怎樣做”，但至於“為什麽這樣做”卻不多說，所以造成大家在基礎和原理方面的知識比較匱乏，所以筆者今天就鬥膽來講一下這個問題，權當拋磚引玉，希望對在這個問題上有疑惑的朋友有所幫助，文中有說的不對的地方，也希望各路高手前來指正。

首先來了解一下jvm（java虛擬機）中的幾個比較重要的內存區域，這幾個區域在java類的生命周期中扮演著比較重要的角色：

  • 方法區：在java的虛擬機中有一塊專門用來存放已經加載的類信息、常量、靜態變量以及方法代碼的內存區域，叫做方法區。
  • 常量池：常量池是方法區的一部分，主要用來存放常量和類中的符號引用等信息。
  • 堆區：用於存放類的對象實例。
  • 棧區：也叫java虛擬機棧，是由一個一個的棧幀組成的後進先出的棧式結構，棧楨中存放方法運行時產生的局部變量、方法出口等信息。當調用一個方法時，虛擬機棧中就會創建一個棧幀存放這些數據，當方法調用完成時，棧幀消失，如果方法中調用了其他方法，則繼續在棧頂創建新的棧楨。

除了以上四個內存區域之外，jvm中的運行時內存區域還包括本地方法棧和程序計數器，這兩個區域與java類的生命周期關系不是很大，在這裏就不說了，感興趣的朋友可以自己百度一下。

類的生命周期

當我們編寫一個java的源文件後，經過編譯會生成一個後綴名為class的文件，這種文件叫做字節碼文件，只有這種字節碼文件才能夠在java虛擬機中運行，java類的生命周期就是指一個class文件從加載到卸載的全過程。

一個java類的完整的生命周期會經歷加載、連接、初始化、使用、和卸載五個階段，當然也有在加載或者連接之後沒有被初始化就直接被使用的情況，如圖所示：

技術分享

下面我們就依次來說一說這五個階段。

加載

在java中，我們經常會接觸到一個詞——類加載，它和這裏的加載並不是一回事，通常我們說類加載指的是類的生命周期中加載、連接、初始化三個階段。在加載階段，java虛擬機會做什麽工作呢？其實很簡單，就是找到需要加載的類並把類的信息加載到jvm的方法區中，然後在堆區中實例化一個java.lang.Class對象，作為方法區中這個類的信息的入口。

類的加載方式比較靈活，我們最常用的加載方式有兩種，一種是根據類的全路徑名找到相應的class文件，然後從class文件中讀取文件內容；另一種是從jar文件中讀取。另外，還有下面幾種方式也比較常用：

  • 從網絡中獲取：比如10年前十分流行的Applet。
  • 根據一定的規則實時生成，比如設計模式中的動態代理模式，就是根據相應的類自動生成它的代理類。
  • 從非class文件中獲取，其實這與直接從class文件中獲取的方式本質上是一樣的，這些非class文件在jvm中運行之前會被轉換為可被jvm所識別的字節碼文件。

對於加載的時機，各個虛擬機的做法並不一樣，但是有一個原則，就是當jvm“預期”到一個類將要被使用時，就會在使用它之前對這個類進行加載。比如說，在一段代碼中出現了一個類的名字，jvm在執行這段代碼之前並不能確定這個類是否會被使用到，於是，有些jvm會在執行前就加載這個類，而有些則在真正需要用的時候才會去加載它，這取決於具體的jvm實現。我們常用的hotspot虛擬機是采用的後者，就是說當真正用到一個類的時候才對它進行加載。

加載階段是類的生命周期中的第一個階段，加載階段之後，是連接階段。有一點需要註意，就是有時連接階段並不會等加載階段完全完成之後才開始，而是交叉進行，可能一個類只加載了一部分之後，連接階段就已經開始了。但是這兩個階段總的開始時間和完成時間總是固定的：加載階段總是在連接階段之前開始，連接階段總是在加載階段完成之後完成。

連接

連接階段比較復雜，一般會跟加載階段和初始化階段交叉進行，這個階段的主要任務就是做一些加載後的驗證工作以及一些初始化前的準備工作，可以細分為三個步驟：驗證、準備和解析。

  1. 驗證：當一個類被加載之後，必須要驗證一下這個類是否合法，比如這個類是不是符合字節碼的格式、變量與方法是不是有重復、數據類型是不是有效、繼承與實現是否合乎標準等等。總之，這個階段的目的就是保證加載的類是能夠被jvm所運行。
  2. 準備：準備階段的工作就是為類的靜態變量分配內存並設為jvm默認的初值，對於非靜態的變量，則不會為它們分配內存。有一點需要註意，這時候，靜態變量的初值為jvm默認的初值，而不是我們在程序中設定的初值。jvm默認的初值是這樣的：
    • 基本類型（int、long、short、char、byte、boolean、float、double）的默認值為0。
    • 引用類型的默認值為null。
    • 常量的默認值為我們程序中設定的值，比如我們在程序中定義final static int a = 100，則準備階段中a的初值就是100。
  3. 解析：這一階段的任務就是把常量池中的符號引用轉換為直接引用。那麽什麽是符號引用，什麽又是直接引用呢？我們來舉個例子：我們要找一個人，我們現有的信息是這個人的身份證號是1234567890。只有這個信息我們顯然找不到這個人，但是通過公安局的身份系統，我們輸入1234567890這個號之後，就會得到它的全部信息：比如安徽省黃山市余暇村18號張三，通過這個信息我們就能找到這個人了。這裏，123456790就好比是一個符號引用，而安徽省黃山市余暇村18號張三就是直接引用。在內存中也是一樣，比如我們要在內存中找一個類裏面的一個叫做show的方法，顯然是找不到。但是在解析階段，jvm就會把show這個名字轉換為指向方法區的的一塊內存地址，比如c17164，通過c17164就可以找到show這個方法具體分配在內存的哪一個區域了。這裏show就是符號引用，而c17164就是直接引用。在解析階段，jvm會將所有的類或接口名、字段名、方法名轉換為具體的內存地址。

連接階段完成之後會根據使用的情況（直接引用還是被動引用）來選擇是否對類進行初始化。

初始化

如果一個類被直接引用，就會觸發類的初始化。在java中，直接引用的情況有：

  • 通過new關鍵字實例化對象、讀取或設置類的靜態變量、調用類的靜態方法。
  • 通過反射方式執行以上三種行為。
  • 初始化子類的時候，會觸發父類的初始化。
  • 作為程序入口直接運行時（也就是直接調用main方法）。

除了以上四種情況，其他使用類的方式叫做被動引用，而被動引用不會觸發類的初始化。請看主動引用的示例代碼：

[java] view plain copy
  1. import java.lang.reflect.Field;
  2. import java.lang.reflect.Method;
  4. class InitClass{
  5. static {
  6. System.out.println("初始化InitClass");
  7. }
  8. public static String a = null;
  9. public static void method(){}
  10. }
  12. class SubInitClass extends InitClass{}
  14. public class Test1 {
  16. /**
  17. * 主動引用引起類的初始化的第四種情況就是運行Test1的main方法時
  18. * 導致Test1初始化，這一點很好理解，就不特別演示了。
  19. * 本代碼演示了前三種情況，以下代碼都會引起InitClass的初始化，
  20. * 但由於初始化只會進行一次，運行時請將註解去掉，依次運行查看結果。
  21. * @param args
  22. * @throws Exception
  23. */
  24. public static void main(String[] args) throws Exception{
  25. // 主動引用引起類的初始化一: new對象、讀取或設置類的靜態變量、調用類的靜態方法。
  26. // new InitClass();
  27. // InitClass.a = "";
  28. // String a = InitClass.a;
  29. // InitClass.method();
  31. // 主動引用引起類的初始化二：通過反射實例化對象、讀取或設置類的靜態變量、調用類的靜態方法。
  32. // Class cls = InitClass.class;
  33. // cls.newInstance();
  35. // Field f = cls.getDeclaredField("a");
  36. // f.get(null);
  37. // f.set(null, "s");
  39. // Method md = cls.getDeclaredMethod("method");
  40. // md.invoke(null, null);
  42. // 主動引用引起類的初始化三：實例化子類，引起父類初始化。
  43. // new SubInitClass();
  45. }
  46. }

上面的程序演示了主動引用觸發類的初始化的四種情況。

類的初始化過程是這樣的：按照順序自上而下運行類中的變量賦值語句和靜態語句，如果有父類，則首先按照順序運行父類中的變量賦值語句和靜態語句。先看一個例子，首先建兩個類用來顯示賦值操作：

[java] view plain copy
  1. public class Field1{
  2. public Field1(){
  3. System.out.println("Field1構造方法");
  4. }
  5. }
  6. public class Field2{
  7. public Field2(){
  8. System.out.println("Field2構造方法");
  9. }
  10. }

下面是演示初始化順序的代碼：

[java] view plain copy
  1. class InitClass2{
  2. static{
  3. System.out.println("運行父類靜態代碼");
  4. }
  5. public static Field1 f1 = new Field1();
  6. public static Field1 f2;
  7. }
  9. class SubInitClass2 extends InitClass2{
  10. static{
  11. System.out.println("運行子類靜態代碼");
  12. }
  13. public static Field2 f2 = new Field2();
  14. }
  16. public class Test2 {
  17. public static void main(String[] args) throws ClassNotFoundException{
  18. new SubInitClass2();
  19. }
  20. }

上面的代碼中，初始化的順序是：第03行，第05行，第11行，第13行。第04行是聲明操作，沒有賦值，所以不會被運行。而下面的代碼：

[java] view plain copy
  1. class InitClass2{
  2. public static Field1 f1 = new Field1();
  3. public static Field1 f2;
  4. static{
  5. System.out.println("運行父類靜態代碼");
  6. }
  7. }
  9. class SubInitClass2 extends InitClass2{
  10. public static Field2 f2 = new Field2();
  11. static{
  12. System.out.println("運行子類靜態代碼");
  13. }
  14. }
  16. public class Test2 {
  17. public static void main(String[] args) throws ClassNotFoundException{
  18. new SubInitClass2();
  19. }
  20. }

初始化順序為：第02行、第05行、第10行、第12行，各位可以運行程序查看結果。

在類的初始化階段，只會初始化與類相關的靜態賦值語句和靜態語句，也就是有static關鍵字修飾的信息，而沒有static修飾的賦值語句和執行語句在實例化對象的時候才會運行。

使用

類的使用包括主動引用和被動引用，主動引用在初始化的章節中已經說過了，下面我們主要來說一下被動引用：

  • 引用父類的靜態字段，只會引起父類的初始化，而不會引起子類的初始化。
  • 定義類數組，不會引起類的初始化。
  • 引用類的常量，不會引起類的初始化。

被動引用的示例代碼：

[java] view plain copy
  1. class InitClass{
  2. static {
  3. System.out.println("初始化InitClass");
  4. }
  5. public static String a = null;
  6. public final static String b = "b";
  7. public static void method(){}
  8. }
  10. class SubInitClass extends InitClass{
  11. static {
  12. System.out.println("初始化SubInitClass");
  13. }
  14. }
  16. public class Test4 {
  18. public static void main(String[] args) throws Exception{
  19. // String a = SubInitClass.a;// 引用父類的靜態字段，只會引起父類初始化，而不會引起子類的初始化
  20. // String b = InitClass.b;// 使用類的常量不會引起類的初始化
  21. SubInitClass[] sc = new SubInitClass[10];// 定義類數組不會引起類的初始化
  22. }
  23. }


最後總結一下使用階段：使用階段包括主動引用和被動引用，主動飲用會引起類的初始化，而被動引用不會引起類的初始化。

當使用階段完成之後，java類就進入了卸載階段。

卸載

關於類的卸載，筆者在單例模式討論篇：單例模式與垃圾回收一文中有過描述，在類使用完之後，如果滿足下面的情況，類就會被卸載：

  • 該類所有的實例都已經被回收，也就是java堆中不存在該類的任何實例。
  • 加載該類的ClassLoader已經被回收。
  • 該類對應的java.lang.Class對象沒有任何地方被引用，無法在任何地方通過反射訪問該類的方法。

如果以上三個條件全部滿足，jvm就會在方法區垃圾回收的時候對類進行卸載，類的卸載過程其實就是在方法區中清空類信息，java類的整個生命周期就結束了。

總結

做java的朋友對於對象的生命周期可能都比較熟悉，對象基本上都是在jvm的堆區中創建，在創建對象之前，會觸發類加載（加載、連接、初始化），當類初始化完成後，根據類信息在堆區中實例化類對象，初始化非靜態變量、非靜態代碼以及默認構造方法，當對象使用完之後會在合適的時候被jvm垃圾收集器回收。讀完本文後我們知道，對象的生命周期只是類的生命周期中使用階段的主動引用的一種情況（即實例化類對象）。而類的整個生命周期則要比對象的生命周期長的多。

學習Java的同學註意了！！！

學習過程中遇到什麽問題或者想獲取學習資源的話，歡迎加入Java學習交流群，群號碼：618528494 我們一起學Java！

詳解Java類的生命周期

相關推薦

java-類生命周期（二）

.net ava 初始化 啟動 pri pos 入口 原理 tails 上文介紹了java-類生命周期（一），理論性比較強。認為太復雜的同學，瞟一下本文的樣例加深理解。 先給道題目，看看答對沒。 /** * 類載入試驗基類 * * @author peter

詳解Java類的生命周期

字段 view 數據類型 分配內存 lar ati final 並不是 編譯 引言 最近有位細心的朋友在閱讀筆者的文章時，對Java類的生命周期問題有一些疑惑，筆者打開百度搜了一下相關的問題，看到網上的資料很少有把這個問題講明白的，主要是因為目前國內Java

java 靜態變量生命周期（類生命周期）

targe ref 鍵值對 靜態代碼塊 經歷 per tails jvm的內存 代碼 轉載自：http://www.cnblogs.com/hf-cherish/p/4970267.html 侵刪 Static： 加載：java虛擬機在加載類的過程中為靜態變量分配

詳解java類的生命週期

引言         最近有位細心的朋友在閱讀筆者的文章時，對java類的生命週期問題有一些疑惑，筆者開啟百度搜了一下相關的問題，看到網上的資料很少有把這個問題講明白的，主要是因為目前國內java方面的教材大多隻是告訴你“怎樣做”，但至於“為什麼這樣做”卻不多說，所以造成大

類生命周期

加載過程 clas 通過 itl char initial 它的 log 階段 類從被加載到虛擬機內存中開始到卸載出內存為止，它的整個生命周期包括：加載（Loading）、驗證（Verification）、準備（Preparation）、解析（Resolution）、初始化

詳解JAVA類加載機制

黑客組織 ati 常量 就業 html 實例化 空間 開發者 分配 JAVA源碼編譯由三個過程組成： 1、源碼編譯機制。 2、類加載機制 3、類執行機制 我們這裏主要介紹編譯和類加載這兩種機制。 一、源碼編譯 代碼編譯由JAVA源碼編譯器來完成。主要是將源碼編譯成字節碼文件

【Vue】詳解Vue生命周期

pda -a clas 文本 con 存在 操作 ef6 註意 Vue實例的生命周期全過程（圖） （這裏的紅邊圓角矩形內的都是對應的Vue實例的鉤子函數） 在beforeCreate和created鉤子函數間的生命周期 在beforeC

maven生命周期和階段詳解

coo col .cn com gym htm cool mta ndk %E5%BE%AE%E8%BD%AF%E5%85%B3%E9%97%AD%E5%85%B6websitespark%E5%BC%80%E5%8F%91%E8%80%85%E8%AE%A1%E5%88%

React—組件生命周期詳解

ack 傳遞 滿足 copyright fun 事件觸發 頂級 工作 tle React—組件生命周期詳解 轉自 明明的博客 http://blog.csdn.net/slandove/article/details/50748473 （非原創） 版權聲明：轉

vue實例生命周期詳解

-s 不可見 back 子函數 put 之前 取數據 進一步 app 每個 Vue 實例在被創建之前都要經過一系列的初始化過程。 例如，實例需要配置數據觀測(data observer)、編譯模版、掛載實例到 DOM ，然後在數據變化時更新 DOM 。 在這個過程中，實例也

Vue入門系列（五）Vue實例詳解與生命周期

auto res context mode parent all from bool silent 【入門系列】 【本文轉自】 　　http://www.cnblogs.com/fly_dragon Vue的實例是Vue框架的入口，其實也就是前端的ViewM

Java-類的生命周期淺析

子接口 c編程 機會 java test static 編譯器 pac 變量聲明 數據位 簡述：Java虛擬機為Java程序提供運行時環境，其中一項重要的任務就是管理類和對象的生命周期。類的生命周期。類的生命周期從類被加載、連接和初始化開始，到類被卸載結束。當類處於生命周期

Spring bean的生命周期詳解

root bsp ram odi www rop ssp package etag bean的生命周期1.實例化bean 即new2.按照spring上下文對實例化的bean進行配置 即填充屬性，也就是IOC/DI（控制反轉，依賴註入）3.如果這個bean實現了BeanNa

JVM類加載器及Java類的生命周期

方法區 exception 獲取 調用 example 應用 contex java語言 ins 預定義類加載器（三種）： 啟動（Bootstrap）類加載器：　　是用本地代碼實現的類裝入器，它負責將<Java_Runtime_Home>/lib下面的類庫加載到

Fragment生命周期詳解

開啟事務 rem destroy ide edi on() 進行 nco === Fragment依附Activity而存在，本文通過兩個TextView切換兩個Fragment來觀察Activity和兩個Fragment在不同操作下各執行哪些方法，從而對其生命周期有更加深

010_React-組件的生命周期詳解

完成 結構 highlight 歡迎信息 cloud IT log 函數 協作 ReactJS 的核心思想是組件化，即按功能封裝成一個一個的組件，各個組件維護自己的狀態和 UI，當狀態發生變化時，會自定重新渲染整個組件，多個組件一起協作共同構成了 ReactJS 應用。 為

Vue生命周期函數詳解

api 新的 for 分類 特點 methods rec .org 實例 vue實例的生命周期 1 什麽是生命周期（每個實例的一輩子） 概念：每一個Vue實例創建、運行、銷毀的過程，就是生命周期；在實例的生命周期中，總是伴隨著各種事件，這些事件就是生命周期函數； 生命周期

Servlet簡介及其生命周期詳解

關於 post方法 創建 destroy 初始化 客戶端 生命周期 般的 destory 簡介 Servlet生命周期，即闡述Servlet從產生到毀滅的整個過程。 在Servlet產生到消亡的過程中，有三個生命周期函數，初始化方法init()

Java類的生命周期

完全 類的加載 ref 修飾 生命 創建對象 除了 區別 類對象 本文轉載自：https://blog.csdn.net/zhengzhb/article/details/7517213 我們在編寫好java文件後會對其進行編譯，稱為class字節碼文件，而Java生命周期

React 生命周期鉤子函數詳解

turn clas () 函數 ted dea truct tor stat 一、回顧vue中的生命周期 beforeCreate created beforeMount mounted b