異常機制實現

1. 代碼層面

實際代碼

try
{
    //就算這里return了,也會調用finally語句，如果finally中也有return，就會抑制這個return。
}
catch (Exception e) 
{    
}
finally 
{    
}

類型

2. 虛擬機層面

異常拋出機制

顯式拋出：由用戶程序寫代碼進行拋出，必須顯式捕獲。 通常是Exception。

隱式拋出：由Java虛擬機的安全檢查進行拋出，比如數組越界檢查、除以0錯誤等等。不用用戶程序捕獲。通常是RunTimeError或者Error

異常捕獲機制

首先JVM為每一個方法生成一個異常表。包括{監控起始語句 監控終止語句 異常類型}

public static void main(String[] args) {
  try {
    mayThrowException();
  } catch (Exception e) {
    e.printStackTrace();
  }
}
// 對應的 Java 字節碼
public static void main(java.lang.String[]);
  Code:
    0: invokestatic mayThrowException:()V
    3: goto 11
    6: astore_1
    7: aload_1
    8: invokevirtual java.lang.Exception.printStackTrace
   11: return
  Exception table:									// 異常表條目
    from  to target type
      0   3   6  Class java/lang/Exception  
12345678910111213141516171819

其中的from和to分別對應著監控的字節碼的代碼。類型就是捕獲的Exception類型。

把finally中的代碼“內聯”到try和catch中各一份，或者只在catch中放一份，在try中放入跳轉指令。

然后如果Exception就直接進入catch語句，如果遇見Error，直接執行了finally。

public class Foo {
  private int tryBlock;
  private int catchBlock;
  private int finallyBlock;
  private int methodExit;
  public void test() {
    try {
      tryBlock = 0;
    } catch (Exception e) {
      catchBlock = 1;
    } finally {
      finallyBlock = 2;
    }
    methodExit = 3;
  }
} 
$ javap -c Foo
...
  public void test();
    Code:
       0: aload_0
       1: iconst_0
       2: putfield      #20                 // Field tryBlock:I
       5: goto          30
       8: astore_1
       9: aload_0
      10: iconst_1
      11: putfield      #22                 // Field catchBlock:I
      14: aload_0
      15: iconst_2
      16: putfield      #24                 // Field finallyBlock:I
      19: goto          35
      22: astore_2
      23: aload_0
      24: iconst_2
      25: putfield      #24                 // Field finallyBlock:I
      28: aload_2
      29: athrow
      30: aload_0
      31: iconst_2
      32: putfield      #24                 // Field finallyBlock:I
      35: aload_0
      36: iconst_3
      37: putfield      #26                 // Field methodExit:I
      40: return
    Exception table:
       from    to  target type
           0     5     8   Class java/lang/Exception
           0    14    22   any 
  ...

可以看到，編譯結果包含三份 finally 代碼塊。其中，前兩份分別位于 try 代碼塊和 catch 代碼塊的正常執行路徑出口。最后一份則作為異常處理器，監控 try 代碼塊以及 catch 代碼塊。它將捕獲 try 代碼塊觸發的、未被 catch 代碼塊捕獲的異常，以及 catch 代碼塊觸發的異常。

3. jdk7的 try-with-resource語句的使用

背景

finally中的語句也有可能拋出錯誤，但是關閉資源這個錯誤的根本原因，可能式第一個被拋出的錯誤引起的，而被拋出的錯誤確實finally語句中的錯誤，從而導致了根本錯誤被supress。

代碼層面實現

所以為了得到第一個錯誤，加入了Surpress機制，反映到代碼層面就是try-with-resource語句。使用try-with-resource語句，會自動關閉資源，從而避免了內存泄漏的問題。另外使用try-with-resource語句，會抑制finally語句中的拋出的錯誤。可以使用addSupress和getSupress獲取全部的Exception。

實例

@Test
public void testJdk7TryWith() {
    try(InputStream inputStream = new FileInputStream(new File("test"))) {

    } catch(Exception e) {
        e.printStackTrace();
    }
}
/*
*
*   由于第一個異?？赡苁歉驹颍敲丛趺催M行捕獲呢？
* */
public static void main(String[] args) throws Exception {
    InputStream in = null;
    Exception ex = null;
    try {
        in = new FileInputStream(new File("tes"));
    } catch (FileNotFoundException e) {
        ex = e;
        throw e;
    } finally {
        try {
            in.close();
        } catch (IOException e) {
            if (ex == null) {
                System.out.println("有這個文件就不拋出了");
                throw e;
            }
        } catch (NullPointerException e) { // 因為in會出現空指針，抑制第一個文件的拋出
            if (ex == null) {
                System.out.println("有這個文件就不拋出了");
            }
        }
    }
}

最后注意

使用鎖，不能使用try-with語句，必須顯式的調用unlock方法。代碼如下

@Test
public void testLock() {
    Lock myLock = new ReentrantLock();
    try {
        myLock.lock();
    } catch (Exception e) {
        throw e;
    } finally {
        myLock.unlock();
    }
}

以上就是關于“Java異常處理機制原理”的介紹，大家如果想了解更多相關知識，可以關注一下動力節點的Java入門視頻教程，里面有更豐富的知識等著大家去學習，希望對大家能夠有所幫助。