1. Classloader的作用，概括來說就是將編譯后的class裝載、加載到機器內存中，為了以后的程序的執行提供前提條件。
2. 一段程序引發的思考：
風中葉老師在他的視頻中給了我們一段程序，號稱是世界上所有的Java程序員都會犯的錯誤。
詭異代碼如下：
Java代碼
- package test01;
-
- class Singleton {
-
- public static Singleton singleton = new Singleton();
- public static int a;
- public static int b = 0;
-
- private Singleton() {
- super();
- a++;
- b++;
- }
-
- public static Singleton GetInstence() {
- return singleton;
- }
-
- }
-
- public class MyTest {
-
- /**
- * @param args
- */
- public static void main(String[] args) {
- Singleton mysingleton = Singleton.GetInstence();
- System.out.println(mysingleton.a);
- System.out.println(mysingleton.b);
- }
-
- }
一般不假思索的結論就是，a=1,b=1。給出的原因是：a、b都是靜態變量，在構造函數調用的時候已經對a和b都加1了。答案就都是1。但是運行完后答案卻是a=1,b=0。
下面我們將代碼稍微變一下
Java代碼
- public static Singleton singleton = new Singleton();
- public static int a;
- public static int b = 0;
的代碼部分替換成
Java代碼
- public static int a;
- public static int b = 0;
- public static Singleton singleton = new Singleton();
效果就是剛才預期的a=1,b=1。
為什么呢，這3句無非就是靜態變量的聲明、初始化，值的變化和聲明的順序還有關系嗎?Java不是面向對象的嗎?怎么和結構化的語言似地，順序還有關系。這個就是和Java虛擬機JVM加載類的原理有著直接的關系。
1. 類在JVM中的工作原理
要想使用一個Java類為自己工作，必須經過以下幾個過程
1)：類加載load：從字節碼二進制文件——.class文件將類加載到內存，從而達到類的從硬盤上到內存上的一個遷移，所有的程序必須加載到內存才能工作。將內存中的class放到運行時數據區的方法區內，之后在堆區建立一個java.lang.Class對象，用來封裝方法區的數據結構。這個時候就體現出了萬事萬物皆對象了，干什么事情都得有個對象。就是到了最底層究竟是雞生蛋，還是蛋生雞呢?類加載的最終產物就是堆中的一個java.lang.Class對象。
2)：連接：連接又分為以下小步驟
驗證：出于安全性的考慮，驗證內存中的字節碼是否符合JVM的規范，類的結構規范、語義檢查、字節碼操作是否合法、這個是為了防止用戶自己建立一個非法的XX.class文件就進行工作了，或者是JVM版本沖突的問題，比如在JDK6下面編譯通過的class(其中包含注解特性的類)，是不能在JDK1.4的JVM下運行的。
準備：將類的靜態變量進行分配內存空間、初始化默認值。(對象還沒生成呢，所以這個時候沒有實例變量什么事情)
解析：把類的符號引用轉為直接引用(保留)
3)：類的初始化： 將類的靜態變量賦予正確的初始值，這個初始值是開發者自己定義時賦予的初始值，而不是默認值。
2. 類的主動使用與被動使用
以下是視為主動使用一個類，其他情況均視為被動使用!
1)：初學者最為常用的new一個類的實例對象(聲明不叫主動使用)
2)：對類的靜態變量進行讀取、賦值操作的。
3)：直接調用類的靜態方法。
4)：反射調用一個類的方法。
5)：初始化一個類的子類的時候，父類也相當于被程序主動調用了(如果調用子類的靜態變量是從父類繼承過來并沒有復寫的，那么也就相當于只用到了父類的東東，和子類無關，所以這個時候子類不需要進行類初始化)。
6)：直接運行一個main函數入口的類。
所有的JVM實現(不同的廠商有不同的實現，有人就說IBM的實現比Sun的要好……)在首次主動調用類和接口的時候才會初始化他們。
1. 類的加載方式
1)：本地編譯好的class中直接加載
2)：網絡加載：java.net.URLClassLoader可以加載url指定的類
3)：從jar、zip等等壓縮文件加載類，自動解析jar文件找到class文件去加載util類
4)：從java源代碼文件動態編譯成為class文件
2. 類加載器
JVM自帶的默認加載器
1)：根類加載器：bootstrap，由C++編寫，所有Java程序無法獲得。
2)：擴展類加載器：由Java編寫。
3)：系統類、應用類加載器：由Java編寫。
用戶自定義的類加載器：java.lang.ClassLoader的子類，用戶可以定制類的加載方式。每一個類都包含了加載他的ClassLoader的一個引用——getClass().getClassLoader()。如果返回的是null，證明加載他的ClassLoader是根加載器bootstrap。
如下代碼
這里面的指針就是C++的指針
1. 回顧那個詭異的代碼
從入口開始看
Singleton mysingleton = Singleton.GetInstence();
是根據內部類的靜態方法要一個Singleton實例。
這個時候就屬于主動調用Singleton類了。
之后內存開始加載Singleton類
1)：對Singleton的所有的靜態變量分配空間，賦默認的值，所以在這個時候，singleton=null、a=0、b=0。注意b的0是默認值，并不是咱們手工為其賦予的的那個0值。
2)：之后對靜態變量賦值，這個時候的賦值就是我們在程序里手工初始化的那個值了。此時singleton = new Singleton();調用了構造方法。構造方法里面a=1、b=1。之后接著順序往下執行。
3)：
- public static int a;
-
- public static int b = 0;
a沒有賦值，保持原狀a=1。b被賦值了，b原先的1值被覆蓋了，b=0。所以結果就是這么來的。類中的靜態塊static塊也是順序地從上到下執行的。
2. 編譯時常量、非編譯時常量的靜態變量
如下代碼
Java代碼
- package test01;
-
- class FinalStatic {
-
- public static final int A = 4 + 4;
-
- static {
- System.out.println("如果執行了，證明類初始化了……");
- }
-
- }
-
- public class MyTest03 {
-
- /**
- * @param args
- */
- public static void main(String[] args) {
- System.out.println(FinalStatic.A);
- }
-
- }
結果是只打印出了8，證明類并沒有初始化。反編譯源碼發現class里面的內容是
public static final int A = 8;
也就是說編譯器很智能的、在編譯的時候自己就能算出4+4是8，是一個固定的數字。沒有什么未知的因素在里面。
將代碼稍微改一下
public static final int A = 4 + new Random().nextInt(10);
這個時候靜態塊就執行了，證明類初始化了。在靜態final變量在編譯時不定的情況下。如果客戶程序這個時候訪問了該類的靜態變量，那就會對類進行初始化，所以盡量靜態final變量盡量沒什么可變因素在里面1，否則性能會有所下降。
1. ClassLoader的剖析
ClassLoader的loadClass方法加載一個類不屬于主動調用，不會導致類的初始化。如下代碼塊
Java代碼
- ClassLoader classLoader = ClassLoader.getSystemClassLoader();
- Class clazz = classLoader.loadClass("test01.ClassDemo");
并不會讓類加載器初始化test01.ClassDemo，因為這不屬于主動調用此類。
ClassLoader的關系：
根加載器——》擴展類加載器——》應用類加載器——》用戶自定義類加載器
加載類的過程是首先從根加載器開始加載、根加載器加載不了的，由擴展類加載器加載，再加載不了的有應用加載器加載，應用加載器如果還加載不了就由自定義的加載器(一定繼承自java.lang. ClassLoader)加載、如果自定義的加載器還加載不了。而且下面已經沒有再特殊的類加載器了，就會拋出ClassNotFoundException，表面上異常是類找不到，實際上是class加載失敗，更不能創建該類的Class對象。
若一個類能在某一層類加載器成功加載，那么這一層的加載器稱為定義類加載器。那么在這層類生成的Class引用返回下一層加載器叫做初始類加載器。因為加載成功后返回一個Class引用給它的服務對象——也就是調用它的類加載器。考慮到安全，父委托加載機制。
ClassLoader加載類的原代碼如下
Java代碼
- protected synchronized Class loadClass(String name, boolean resolve)
- throws ClassNotFoundException
- {
- // First, check if the class has already been loaded
- Class c = findLoadedClass(name);
- if (c == null) {
- try {
- if (parent != null) {
- c = parent.loadClass(name, false);
- } else {
- c = findBootstrapClassOrNull(name);
- }
- } catch (ClassNotFoundException e) {
- // ClassNotFoundException thrown if class not found
- // from the non-null parent class loader
- }
- if (c == null) {
- // If still not found, then invoke findClass in order
- // to find the class.
- c = findClass(name);
- }
- }
- if (resolve) {
- resolveClass(c);
- }
- return c;
- }
初始化系統ClassLoader代碼如下
Java代碼
- private static synchronized void initSystemClassLoader() {
- if (!sclSet) {
- if (scl != null)
- throw new IllegalStateException("recursive invocation");
- sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
- if (l != null) {
- Throwable oops = null;
- scl = l.getClassLoader();
- try {
- PrivilegedExceptionAction a;
- a = new SystemClassLoaderAction(scl);
- scl = (ClassLoader) AccessController.doPrivileged(a);
- } catch (PrivilegedActionException pae) {
- oops = pae.getCause();
- if (oops instanceof InvocationTargetException) {
- oops = oops.getCause();
- }
- }
- if (oops != null) {
- if (oops instanceof Error) {
- throw (Error) oops;
- } else {
- // wrap the exception
- throw new Error(oops);
- }
- }
- }
- sclSet = true;
- }
- }
它里面調用了很多native的方法，也就是通過JNI調用底層C++的代碼。
當一個類被加載、連接、初始化后，它的生命周期就開始了，當代表該類的Class對象不再被引用、即已經不可觸及的時候，Class對象的生命周期結束。那么該類的方法區內的數據也會被卸載，從而結束該類的生命周期。一個類的生命周期取決于它Class對象的生命周期。由Java虛擬機自帶的默認加載器(根加載器、擴展加載器、系統加載器)所加載的類在JVM生命周期中始終不被卸載。所以這些類的Class對象(我稱其為實例的模板對象)始終能被觸及!而由用戶自定義的類加載器所加載的類會被卸載掉!