八、深入理解java異常處理機制
- 引子
try…catch…finally恐怕是大家再熟悉不過的語句了，
public class TestException {
public TestException() {
}
boolean testEx() throws Exception {
boolean ret = true;
try {
ret = testEx1();
} catch (Exception e) {
System.out.println("testEx, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx, finally; return value=" + ret);
return ret;
}
}
boolean testEx1() throws Exception {
boolean ret = true;
try {
ret = testEx2();
if (!ret) {
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
} catch (Exception e) {
System.out.println("testEx1, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx1, finally; return value=" + ret);
return ret;
}
}
boolean testEx2() throws Exception {
boolean ret = true;
try {
int b = 12;
int c;
for (int i = 2; i >= -2; i--) {
c = b / i;
System.out.println("i=" + i);
}
return true;
} catch (Exception e) {
System.out.println("testEx2, catch exception");
ret = false;
throw e;
} finally {
System.out.println("testEx2, finally; return value=" + ret);
return ret;
}
}
public static void main(String[] args) {
TestException testException1 = new TestException();
try {
testException1.testEx();
} catch (Exception e) {
e.printStackTrace();
}
}
}
你的答案是什么？是下面的答案嗎？
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false
如果你的答案真的如上面所說，那么你錯啦。_，那就建議你仔細看一看這篇文章或者拿上面的代碼按各種不同的情況修改、執行、測試，你會發現有很多事情不是原來想象中的那么簡單的。現在公布正確答案：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false
注意說明：
finally語句塊不應該出現 應該出現return。上面的return ret最好是其他語句來處理相關邏輯。
2.JAVA異常
異常指不期而至的各種狀況，如：文件找不到、網絡連接失敗、非法參數等。異常是一個事件，它發生在程序運行期間，干擾了正常的指令流程。Java通 過API中Throwable類的眾多子類描述各種不同的異常。因而，Java異常都是對象，是Throwable子類的實例，描述了出現在一段編碼中的 錯誤條件。當條件生成時，錯誤將引發異常。
Java異常類層次結構圖：
在 Java 中，所有的異常都有一個共同的祖先 Throwable（可拋出）。Throwable 指定代碼中可用異常傳播機制通過 Java 應用程序傳輸的任何問題的共性。
Throwable： 有兩個重要的子類：Exception（異常）和 Error（錯誤），二者都是 Java 異常處理的重要子類，各自都包含大量子類。
Error（錯誤）:是程序無法處理的錯誤，表示運行應用程序中較嚴重問題。大多數錯誤與代碼編寫者執行的操作無關，而表示代碼運行時 JVM（Java 虛擬機）出現的問題。例如，Java虛擬機運行錯誤（Virtual MachineError），當 JVM 不再有繼續執行操作所需的內存資源時，將出現 OutOfMemoryError。這些異常發生時，Java虛擬機（JVM）一般會選擇線程終止。
這些錯誤表示故障發生于虛擬機自身、或者發生在虛擬機試圖執行應用時，如Java虛擬機運行錯誤（Virtual MachineError）、類定義錯誤（NoClassDefFoundError）等。這些錯誤是不可查的，因為它們在應用程序的控制和處理能力之 外，而且絕大多數是程序運行時不允許出現的狀況。對于設計合理的應用程序來說，即使確實發生了錯誤，本質上也不應該試圖去處理它所引起的異常狀況。在 Java中，錯誤通過Error的子類描述。
Exception（異常）:是程序本身可以處理的異常。
Exception 類有一個重要的子類 RuntimeException。RuntimeException 類及其子類表示“JVM 常用操作”引發的錯誤。例如，若試圖使用空值對象引用、除數為零或數組越界，則分別引發運行時異常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。
注意：異常和錯誤的區別：異常能被程序本身可以處理，錯誤是無法處理。
通常，Java的異常(包括Exception和Error)分為可查的異常（checked exceptions）和不可查的異常（unchecked exceptions）。
可查異常（編譯器要求必須處置的異常）：正確的程序在運行中，很容易出現的、情理可容的異常狀況。可查異常雖然是異常狀況，但在一定程度上它的發生是可以預計的，而且一旦發生這種異常狀況，就必須采取某種方式進行處理。
除了RuntimeException及其子類以外，其他的Exception類及其子類都屬于可查異常。這種異常的特點是Java編譯器會檢查它，也就是說，當程序中可能出現這類異常，要么用try-catch語句捕獲它，要么用throws子句聲明拋出它，否則編譯不會通過。
不可查異常(編譯器不要求強制處置的異常):包括運行時異常（RuntimeException與其子類）和錯誤（Error）。
Exception 這種異常分兩大類運行時異常和非運行時異常(編譯異常)。程序中應當盡可能去處理這些異常。
運行時異常：都是RuntimeException類及其子類異常，如NullPointerException(空指針異常)、IndexOutOfBoundsException(下標越界異常)等，這些異常是不檢查異常，程序中可以選擇捕獲處理，也可以不處理。這些異常一般是由程序邏輯錯誤引起的，程序應該從邏輯角度盡可能避免這類異常的發生。
運行時異常的特點是Java編譯器不會檢查它，也就是說，當程序中可能出現這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句聲明拋出它，也會編譯通過。
非運行時異常 （編譯異常）：是RuntimeException以外的異常，類型上都屬于Exception類及其子類。從程序語法角度講是必須進行處理的異常，如果不處理，程序就不能編譯通過。如IOException、SQLException等以及用戶自定義的Exception異常，一般情況下不自定義檢查異常。
4.處理異常機制
在 Java 應用程序中，異常處理機制為：拋出異常，捕捉異常。
拋出異常：當一個方法出現錯誤引發異常時，方法創建異常對象并交付運行時系統，異常對象中包含了異常類型和異常出現時的程序狀態等異常信息。運行時系統負責尋找處置異常的代碼并執行。
捕獲異常：在方法拋出異常之后，運行時系統將轉為尋找合適的異常處理器（exception handler）。潛在的異常處理器是異常發生時依次存留在調用棧中的方法的集合。當異常處理器所能處理的異常類型與方法拋出的異常類型相符時，即為合適 的異常處理器。運行時系統從發生異常的方法開始，依次回查調用棧中的方法，直至找到含有合適異常處理器的方法并執行。當運行時系統遍歷調用棧而未找到合適 的異常處理器，則運行時系統終止。同時，意味著Java程序的終止。
對于運行時異常、錯誤或可查異常，Java技術所要求的異常處理方式有所不同。
由于運行時異常的不可查性，為了更合理、更容易地實現應用程序，Java規定，運行時異常將由Java運行時系統自動拋出，允許應用程序忽略運行時異常。
對于方法運行中可能出現的Error，當運行方法不欲捕捉時，Java允許該方法不做任何拋出聲明。因為，大多數Error異常屬于永遠不能被允許發生的狀況，也屬于合理的應用程序不該捕捉的異常。
對于所有的可查異常，Java規定：一個方法必須捕捉，或者聲明拋出方法之外。也就是說，當一個方法選擇不捕捉可查異常時，它必須聲明將拋出異常。
能夠捕捉異常的方法，需要提供相符類型的異常處理器。所捕捉的異常，可能是由于自身語句所引發并拋出的異常，也可能是由某個調用的方法或者Java運行時 系統等拋出的異常。也就是說，一個方法所能捕捉的異常，一定是Java代碼在某處所拋出的異常。簡單地說，異常總是先被拋出，后被捕捉的。
任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運行時系統。無論是誰，都可以通過Java的throw語句拋出異常。
從方法中拋出的任何異常都必須使用throws子句。
捕捉異常通過try-catch語句或者try-catch-finally語句實現。
總體來說，Java規定：對于可查異常必須捕捉、或者聲明拋出。允許忽略不可查的RuntimeException和Error。
4.1 捕獲異常：try、catch 和 finally
1.try-catch語句
在Java中，異常通過try-catch語句捕獲。其一般語法形式為：
try {
// 可能會發生異常的程序代碼
} catch (Type1 id1){
// 捕獲并處置try拋出的異常類型Type1
}
catch (Type2 id2){
//捕獲并處置try拋出的異常類型Type2
}
關鍵詞try后的一對大括號將一塊可能發生異常的代碼包起來，稱為監控區域。Java方法在運行過程中出現異常，則創建異常對象。將異常拋出監控區域之 外，由Java運行時系統試圖尋找匹配的catch子句以捕獲異常。若有匹配的catch子句，則運行其異常處理代碼，try-catch語句結束。
匹配的原則是：如果拋出的異常對象屬于catch子句的異常類，或者屬于該異常類的子類，則認為生成的異常對象與catch塊捕獲的異常類型相匹配。
例1 捕捉throw語句拋出的“除數為0”異常。
public class TestException {
public static void main(String[] args) {
int a = 6;
int b = 0;
try { // try監控區域
if (b == 0) throw new ArithmeticException(); // 通過throw語句拋出異常
System.out.println("a/b的值是：" + a / b);
}
catch (ArithmeticException e) { // catch捕捉異常
System.out.println("程序出現異常，變量b不能為0。");
}
System.out.println("程序正常結束。");
}
}
運行結果：程序出現異常，變量b不能為0。程序正常結束。
例1 在try監控區域通過if語句進行判斷，當“除數為0”的錯誤條件成立時引發ArithmeticException異常，創建 ArithmeticException異常對象，并由throw語句將異常拋給Java運行時系統，由系統尋找匹配的異常處理器catch并運行相應異 常處理代碼，打印輸出“程序出現異常，變量b不能為0。”try-catch語句結束，繼續程序流程。
事實上，“除數為0”等ArithmeticException，是RuntimException的子類。而運行時異常將由運行時系統自動拋出，不需要使用throw語句。
例2 捕捉運行時系統自動拋出“除數為0”引發的ArithmeticException異常。
public static void main(String[] args) {
int a = 6;
int b = 0;
try {
System.out.println("a/b的值是：" + a / b);
} catch (ArithmeticException e) {
System.out.println("程序出現異常，變量b不能為0。");
}
System.out.println("程序正常結束。");
}
}
運行結果：程序出現異常，變量b不能為0。程序正常結束。
例2 中的語句：
System.out.println("a/b的值是：" + a/b);
在運行中出現“除數為0”錯誤，引發ArithmeticException異常。運行時系統創建異常對象并拋出監控區域，轉而匹配合適的異常處理器catch，并執行相應的異常處理代碼。
由于檢查運行時異常的代價遠大于捕捉異常所帶來的益處，運行時異常不可查。Java編譯器允許忽略運行時異常，一個方法可以既不捕捉，也不聲明拋出運行時異常。
例3 不捕捉、也不聲明拋出運行時異常。
public class TestException {
public static void main(String[] args) {
int a, b;
a = 6;
b = 0; // 除數b 的值為0
System.out.println(a / b);
}
}
運行結果：
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.TestException.main(TestException.java:8)
例4 程序可能存在除數為0異常和數組下標越界異常。
public class TestException {
public static void main(String[] args) {
int[] intArray = new int[3];
try {
for (int i = 0; i <= intArray.length; i++) {
intArray[i] = i;
System.out.println("intArray[" + i + "] = " + intArray[i]);
System.out.println("intArray[" + i + "]模 " + (i - 2) + "的值: "
+ intArray[i] % (i - 2));
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("intArray數組下標越界異常。");
} catch (ArithmeticException e) {
System.out.println("除數為0異常。");
}
System.out.println("程序正常結束。");
}
}
運行結果：
intArray[0] = 0
intArray[0]模 -2的值: 0
intArray[1] = 1
intArray[1]模 -1的值: 0
intArray[2] = 2
除數為0異常。
程序正常結束。
例4 程序可能會出現除數為0異常，還可能會出現數組下標越界異常。程序運行過程中ArithmeticException異常類型是先行匹配的，因此執行相匹配的catch語句：
catch (ArithmeticException e){
System.out.println("除數為0異常。");
}
需要注意的是，一旦某個catch捕獲到匹配的異常類型，將進入異常處理代碼。一經處理結束，就意味著整個try-catch語句結束。其他的catch子句不再有匹配和捕獲異常類型的機會。
Java通過異常類描述異常類型，異常類的層次結構如圖1所示。對于有多個catch子句的異常程序而言，應該盡量將捕獲底層異常類的catch子句放在前面，同時盡量將捕獲相對高層的異常類的catch子句放在后面。否則，捕獲底層異常類的catch子句將可能會被屏蔽。
RuntimeException異常類包括運行時各種常見的異常，ArithmeticException類和ArrayIndexOutOfBoundsException類都是它的子類。因此，RuntimeException異常類的catch子句應該放在 最后面，否則可能會屏蔽其后的特定異常處理或引起編譯錯誤。
- try－catch-finally語句
try-catch語句還可以包括第三部分，就是finally子句。它表示無論是否出現異常，都應當執行的內容。try-catch-finally語句的一般語法形式為：
try {
// 可能會發生異常的程序代碼
} catch (Type1 id1) {
// 捕獲并處理try拋出的異常類型Type1
} catch (Type2 id2) {
// 捕獲并處理try拋出的異常類型Type2
} finally {
// 無論是否發生異常，都將執行的語句塊
}
例5 帶finally子句的異常處理程序。
public class TestException {
public static void main(String args[]) {
int i = 0;
String greetings[] = { " Hello world !", " Hello World !! ",
" HELLO WORLD !!!" };
while (i < 4) {
try {
// 特別注意循環控制變量i的設計，避免造成無限循環
System.out.println(greetings[i++]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("數組下標越界異常");
} finally {
System.out.println("--------------------------");
}
}
}
}
運行結果：
Hello world !
--------------------------
Hello World !!
--------------------------
HELLO WORLD !!!
--------------------------
數組下標越界異常
--------------------------
在例5中，請特別注意try子句中語句塊的設計，如果設計為如下，將會出現死循環。如果設計為：
try {
System.out.println (greetings[i]); i++;
}
小結：
try 塊：用于捕獲異常。其后可接零個或多個catch塊，如果沒有catch塊，則必須跟一個finally塊。
catch 塊：用于處理try捕獲到的異常。
finally 塊：無論是否捕獲或處理異常，finally塊里的語句都會被執行。當在try塊或catch塊中遇到return語句時，finally語句塊將在方法返回之前被執行。在以下4種特殊情況下，finally塊不會被執行：
1）在finally語句塊中發生了異常。
2）在前面的代碼中用了System.exit()退出程序。
3）程序所在的線程死亡。
4）關閉CPU。
- try-catch-finally 規則(異常處理語句的語法規則）：
- 必須在 try 之后添加 catch 或 finally 塊。try 塊后可同時接 catch 和 finally 塊，但至少有一個塊。
- 必須遵循塊順序：若代碼同時使用 catch 和 finally 塊，則必須將 catch 塊放在 try 塊之后。
- catch 塊與相應的異常類的類型相關。
- 一個 try 塊可能有多個 catch 塊。若如此，則執行第一個匹配塊。即Java虛擬機會把實際拋出的異常對象依次和各個catch代碼塊聲明的異常類型匹配，如果異常對象為某個異常類型或其子類的實例，就執行這個catch代碼塊，不會再執行其他的 catch代碼塊
- 可嵌套 try-catch-finally 結構。
- 在 try-catch-finally 結構中，可重新拋出異常。
- 除了下列情況，總將執行 finally 做為結束：JVM 過早終止（調用 System.exit(int)）；在 finally 塊中拋出一個未處理的異常；計算機斷電、失火、或遭遇病毒攻擊。
- try、catch、finally語句塊的執行順序:
1)當try沒有捕獲到異常時：try語句塊中的語句逐一被執行，程序將跳過catch語句塊，執行finally語句塊和其后的語句；
2)當try語句塊里的某條語句出現異常時，而沒有處理此異常的catch語句塊時，此異常將會拋給JVM處理，finally語句塊里的語句還是會被執行，但finally語句塊后的語句不會被執行；
3)當try捕獲到異常，catch語句塊里有處理此異常的情況：在try語句塊中是按照順序來執行的，當執行到某一條語句出現異常時，程序將跳到catch語句塊，并與catch語句塊逐一匹配，找到與之對應的處理程序，其他的catch語句塊將不會被執行，而try語句塊中，出現異常之后的語句也不會被執行，catch語句塊執行完后，執行finally語句塊里的語句，最后執行finally語句塊后的語句；
圖示try、catch、finally語句塊的執行：
4.2 拋出異常
任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運行時系統。無論是誰，都可以通過Java的throw語句拋出異常。從方法中拋出的任何異常都必須使用throws子句。
- throws拋出異常
如果一個方法可能會出現異常，但沒有能力處理這種異常，可以在方法聲明處用throws子句來聲明拋出異常。例如汽車在運行時可能會出現故障，汽車本身沒辦法處理這個故障，那就讓開車的人來處理。
throws語句用在方法定義時聲明該方法要拋出的異常類型，如果拋出的是Exception異常類型，則該方法被聲明為拋出所有的異常。多個異常可使用逗號分割。throws語句的語法格式為：
1.methodname throws Exception1,Exception2,..,ExceptionN {
}
方法名后的throws Exception1,Exception2,...,ExceptionN 為聲明要拋出的異常列表。當方法拋出異常列表的異常時，方法將不對這些類型及其子類類型的異常作處理，而拋向調用該方法的方法，由他去處理。例如：
import java.lang.Exception;
public class TestException {
static void pop() throws NegativeArraySizeException {
// 定義方法并拋出NegativeArraySizeException異常
int[] arr = new int[-3]; // 創建數組
}
public static void main(String[] args) { // 主方法
try { // try語句處理異常信息
pop(); // 調用pop()方法
} catch (NegativeArraySizeException e) {
System.out.println("pop()方法拋出的異常");// 輸出異常信息
}
}
}
使用throws關鍵字將異常拋給調用者后，如果調用者不想處理該異常，可以繼續向上拋出，但最終要有能夠處理該異常的調用者。
pop方法沒有處理異常NegativeArraySizeException，而是由main函數來處理。
Throws拋出異常的規則：
1) 如果是不可查異常（unchecked exception），即Error、RuntimeException或它們的子類，那么可以不使用throws關鍵字來聲明要拋出的異常，編譯仍能順利通過，但在運行時會被系統拋出。
2）必須聲明方法可拋出的任何可查異常（checked exception）。即如果一個方法可能出現受可查異常，要么用try-catch語句捕獲，要么用throws子句聲明將它拋出，否則會導致編譯錯誤
3)僅當拋出了異常，該方法的調用者才必須處理或者重新拋出該異常。當方法的調用者無力處理該異常的時候，應該繼續拋出，而不是囫圇吞棗。
4）調用方法必須遵循任何可查異常的處理和聲明規則。若覆蓋一個方法，則不能聲明與覆蓋方法不同的異常。聲明的任何異常必須是被覆蓋方法所聲明異常的同類或子類。
例如：
void method1() throws IOException{} //合法
//編譯錯誤，必須捕獲或聲明拋出IOException
void method2(){
method1();
}
//合法，聲明拋出IOException
void method3()throws IOException {
method1();
}
//合法，聲明拋出Exception，IOException是Exception的子類
void method4()throws Exception {
method1();
}
//合法，捕獲IOException
void method5(){
try{
method1();
}catch(IOException e){…}
}
//編譯錯誤，必須捕獲或聲明拋出Exception
void method6(){
try{
method1();
}catch(IOException e){throw new Exception();}
}
//合法，聲明拋出Exception
void method7()throws Exception{
try{
method1();
}catch(IOException e){throw new Exception();}
}
判斷一個方法可能會出現異常的依據如下：
1）方法中有throw語句。例如，以上method7()方法的catch代碼塊有throw語句。
2）調用了其他方法，其他方法用throws子句聲明拋出某種異常。例如，method3()方法調用了method1()方法，method1()方法聲明拋出IOException，因此，在method3()方法中可能會出現IOException。
- 使用throw拋出異常
throw總是出現在函數體中，用來拋出一個Throwable類型的異常。程序會在throw語句后立即終止，它后面的語句執行不到，然后在包含它的所有try塊中（可能在上層調用函數中）從里向外尋找含有與其匹配的catch子句的try塊。
我們知道，異常是異常類的實例對象，我們可以創建異常類的實例對象通過throw語句拋出。該語句的語法格式為：
throw new exceptionname;
例如拋出一個IOException類的異常對象：
throw new IOException;
要注意的是，throw 拋出的只能夠是可拋出類Throwable 或者其子類的實例對象。下面的操作是錯誤的：
throw new String("exception");
這是因為String 不是Throwable 類的子類。
如果拋出了檢查異常，則還應該在方法頭部聲明方法可能拋出的異常類型。該方法的調用者也必須檢查處理拋出的異常。
如果所有方法都層層上拋獲取的異常，最終JVM會進行處理，處理也很簡單，就是打印異常消息和堆棧信息。如果拋出的是Error或RuntimeException，則該方法的調用者可選擇處理該異常。
import java.lang.Exception;
public class TestException {
static int quotient(int x, int y) throws MyException { // 定義方法拋出異常
if (y < 0) { // 判斷參數是否小于0
throw new MyException("除數不能是負數"); // 異常信息
}
return x/y; // 返回值
}
public static void main(String args[]) { // 主方法
int a =3;
int b =0;
try { // try語句包含可能發生異常的語句
int result = quotient(a, b); // 調用方法quotient()
} catch (MyException e) { // 處理自定義異常
System.out.println(e.getMessage()); // 輸出異常信息
} catch (ArithmeticException e) { // 處理ArithmeticException異常
System.out.println("除數不能為0"); // 輸出提示信息
} catch (Exception e) { // 處理其他異常
System.out.println("程序發生了其他的異常"); // 輸出提示信息
}
}
}
class MyException extends Exception { // 創建自定義異常類
String message; // 定義String類型變量
public MyException(String ErrorMessagr) { // 父類方法
message = ErrorMessagr;
}
public String getMessage() { // 覆蓋getMessage()方法
return message;
}
}
4.3 異常鏈
- 如果調用quotient(3,-1)，將發生MyException異常，程序調轉到catch (MyException e)代碼塊中執行；
- 如果調用quotient(5,0)，將會因“除數為0”錯誤引發ArithmeticException異常，屬于運行時異常類，由Java運行時系統自動拋出。quotient（）方法沒有捕捉ArithmeticException異常，Java運行時系統將沿方法調用棧查到main方法，將拋出的異常上傳至quotient（）方法的調用者：
int result = quotient(a, b); // 調用方法quotient()
由于該語句在try監控區域內，因此傳回的“除數為0”的ArithmeticException異常由Java運行時系統拋出，并匹配catch子句：
catch (ArithmeticException e) { // 處理ArithmeticException異常
System.out.println("除數不能為0"); // 輸出提示信息
}
處理結果是輸出“除數不能為0”。Java這種向上傳遞異常信息的處理機制，形成異常鏈。
Java方法拋出的可查異常將依據調用棧、沿著方法調用的層次結構一直傳遞到具備處理能力的調用方法，最高層次到main方法為止。如果異常傳遞到main方法，而main不具備處理能力，也沒有通過throws聲明拋出該異常，將可能出現編譯錯誤。
3)如還有其他異常發生，將使用catch (Exception e)捕捉異常。由于Exception是所有異常類的父類，如果將catch (Exception e)代碼塊放在其他兩個代碼塊的前面，后面的代碼塊將永遠得不到執行，就沒有什么意義了，所以catch語句的順序不可掉換。
4.4 Throwable類中的常用方法
注意：catch關鍵字后面括號中的Exception類型的參數e。Exception就是try代碼塊傳遞給catch代碼塊的變量類型，e就是變量名。catch代碼塊中語句"e.getMessage();"用于輸出錯誤性質。通常異常處理常用3個函數來獲取異常的有關信息:
getCause()：返回拋出異常的原因。如果 cause 不存在或未知，則返回 null。
getMeage()：返回異常的消息信息。
printStackTrace()：對象的堆棧跟蹤輸出至錯誤輸出流，作為字段 System.err 的值。
有時為了簡單會忽略掉catch語句后的代碼，這樣try-catch語句就成了一種擺設，一旦程序在運行過程中出現了異常，就會忽略處理異常，而錯誤發生的原因很難查找。
5.Java常見異常
在Java中提供了一些異常用來描述經常發生的錯誤，對于這些異常，有的需要程序員進行捕獲處理或聲明拋出，有的是由Java虛擬機自動進行捕獲處理。Java中常見的異常類:
- runtimeException子類:
1、 java.lang.ArrayIndexOutOfBoundsException
數組索引越界異常。當對數組的索引值為負數或大于等于數組大小時拋出。
2、java.lang.ArithmeticException
算術條件異常。譬如：整數除零等。
3、java.lang.NullPointerException
空指針異常。當應用試圖在要求使用對象的地方使用了null時，拋出該異常。譬如：調用null對象的實例方法、訪問null對象的屬性、計算null對象的長度、使用throw語句拋出null等等
4、java.lang.ClassNotFoundException
找不到類異常。當應用試圖根據字符串形式的類名構造類，而在遍歷CLASSPAH之后找不到對應名稱的class文件時，拋出該異常。
5、java.lang.NegativeArraySizeException 數組長度為負異常
6、java.lang.ArrayStoreException 數組中包含不兼容的值拋出的異常
7、java.lang.SecurityException 安全性異常
8、java.lang.IllegalArgumentException 非法參數異常
2.IOException
IOException：操作輸入流和輸出流時可能出現的異常。
EOFException 文件已結束異常
FileNotFoundException 文件未找到異常
- 其他
ClassCastException 類型轉換異常類
ArrayStoreException 數組中包含不兼容的值拋出的異常
SQLException 操作數據庫異常類
NoSuchFieldException 字段未找到異常
NoSuchMethodException 方法未找到拋出的異常
NumberFormatException 字符串轉換為數字拋出的異常
StringIndexOutOfBoundsException 字符串索引超出范圍拋出的異常
IllegalAccessException 不允許訪問某類異常
InstantiationException 當應用程序試圖使用Class類中的newInstance()方法創建一個類的實例，而指定的類對象無法被實例化時，拋出該異常
6.自定義異常
使用Java內置的異常類可以描述在編程時出現的大部分異常情況。除此之外，用戶還可以自定義異常。用戶自定義異常類，只需繼承Exception類即可。
在程序中使用自定義異常類，大體可分為以下幾個步驟。
（1）創建自定義異常類。
（2）在方法中通過throw關鍵字拋出異常對象。
（3）如果在當前拋出異常的方法中處理異常，可以使用try-catch語句捕獲并處理；否則在方法的聲明處通過throws關鍵字指明要拋出給方法調用者的異常，繼續進行下一步操作。
（4）在出現異常方法的調用者中捕獲并處理異常。
在上面的“使用throw拋出異常”例子已經提到了。
九、JVM調優
（一）-- 一些概念
Java虛擬機中，數據類型可以分為兩類：基本類型和引用類型。基本類型的變量保存原始值，即：他代表的值就是數值本身；而引用類型的變量保存引用值。“引用值”代表了某個對象的引用，而不是對象本身，對象本身存放在這個引用值所表示的地址的位置。
基本類型包括：byte,short,int,long,char,float,double,Boolean,returnAddress
引用類型包括：類類型，接口類型和數組。(String也是引用類型)
堆與棧
堆和棧是程序運行的關鍵，很有必要把他們的關系說清楚。
棧是運行時的單位，而堆是存儲的單位。
棧解決程序的運行問題，即程序如何執行，或者說如何處理數據；堆解決的是數據存儲的問題，即數據怎么放、放在哪兒。
在Java中一個線程就會相應有一個線程棧與之對應，這點很容易理解，因為不同的線程執行邏輯有所不同，因此需要一個獨立的線程棧。而堆則是所有線程共享的。棧因為是運行單位，因此里面存儲的信息都是跟當前線程（或程序）相關信息的。包括局部變量、程序運行狀態、方法返回值等等；而堆只負責存儲對象信息。
為什么要把堆和棧區分出來呢？棧中不是也可以存儲數據嗎？
第一，從軟件設計的角度看，棧代表了處理邏輯，而堆代表了數據。這樣分開，使得處理邏輯更為清晰。分而治之的思想。這種隔離、模塊化的思想在軟件設計的方方面面都有體現。
第二，堆與棧的分離，使得堆中的內容可以被多個棧共享（也可以理解為多個線程訪問同一個對象）。這種共享的收益是很多的。一方面這種共享提供了一種有效的數據交互方式(如：共享內存)，另一方面，堆中的共享常量和緩存可以被所有棧訪問，節省了空間。
第三，棧因為運行時的需要，比如保存系統運行的上下文，需要進行地址段的劃分。由于棧只能向上增長，因此就會限制住棧存儲內容的能力。而堆不同，堆中的對象是可以根據需要動態增長的，因此棧和堆的拆分，使得動態增長成為可能，相應棧中只需記錄堆中的一個地址即可。
第四，面向對象就是堆和棧的完美結合。其實，面向對象方式的程序與以前結構化的程序在執行上沒有任何區別。但是，面向對象的引入，使得對待問題的思考方式發生了改變，而更接近于自然方式的思考。當我們把對象拆開，你會發現，對象的屬性其實就是數據，存放在堆中；而對象的行為（方法），就是運行邏輯，放在棧中。我們在編寫對象的時候，其實即編寫了數據結構，也編寫的處理數據的邏輯。不得不承認，面向對象的設計，確實很美。
在Java中，Main函數就是棧的起始點，也是程序的起始點。
程序要運行總是有一個起點的。同C語言一樣，java中的Main就是那個起點。無論什么java程序，找到main就找到了程序執行的入口：）
堆中存什么？棧中存什么？
堆中存的是對象。棧中存的是基本數據類型和堆中對象的引用。一個對象的大小是不可估計的，或者說是可以動態變化的，但是在棧中，一個對象只對應了一個4btye的引用（堆棧分離的好處：））。
為什么不把基本類型放堆中呢？因為其占用的空間一般是1~8個字節——需要空間比較少，而且因為是基本類型，所以不會出現動態增長的情況——長度固定，因此棧中存儲就夠了，如果把他存在堆中是沒有什么意義的（還會浪費空間，后面說明）。可以這么說，基本類型和對象的引用都是存放在棧中，而且都是幾個字節的一個數，因此在程序運行時，他們的處理方式是統一的。但是基本類型、對象引用和對象本身就有所區別了，因為一個是棧中的數據一個是堆中的數據。最常見的一個問題就是，Java中參數傳遞時的問題。
Java中的參數傳遞時傳值呢？還是傳引用？
要說明這個問題，先要明確兩點：
- 不要試圖與C進行類比，Java中沒有指針的概念
- 程序運行永遠都是在棧中進行的，因而參數傳遞時，只存在傳遞基本類型和對象引用的問題。不會直接傳對象本身。
明確以上兩點后。Java在方法調用傳遞參數時，因為沒有指針，所以它都是進行傳值調用（這點可以參考C的傳值調用）。因此，很多書里面都說Java是進行傳值調用，這點沒有問題，而且也簡化的C中復雜性。
但是傳引用的錯覺是如何造成的呢？在運行棧中，基本類型和引用的處理是一樣的，都是傳值，所以，如果是傳引用的方法調用，也同時可以理解為“傳引用值”的傳值調用，即引用的處理跟基本類型是完全一樣的。但是當進入被調用方法時，被傳遞的這個引用的值，被程序解釋（或者查找）到堆中的對象，這個時候才對應到真正的對象。如果此時進行修改，修改的是引用對應的對象，而不是引用本身，即：修改的是堆中的數據。所以這個修改是可以保持的了。
對象，從某種意義上說，是由基本類型組成的。可以把一個對象看作為一棵樹，對象的屬性如果還是對象，則還是一顆樹（即非葉子節點），基本類型則為樹的葉子節點。
程序參數傳遞時，被傳遞的值本身都是不能進行修改的，但是，如果這個值是一個非葉子節點（即一個對象引用），則可以修改這個節點下面的所有內容。
堆和棧中，棧是程序運行最根本的東西。程序運行可以沒有堆，但是不能沒有棧。而堆是為棧進行數據存儲服務，說白了堆就是一塊共享的內存。不過，正是因為堆和棧的分離的思想，才使得Java的垃圾回收成為可能。
Java中，棧的大小通過-Xss來設置，當棧中存儲數據比較多時，需要適當調大這個值，否則會出現java.lang.StackOverflowError異常。常見的出現這個異常的是無法返回的遞歸，因為此時棧中保存的信息都是方法返回的記錄點。
1.（二）一些概念
Java對象的大小
基本數據的類型的大小是固定的，這里就不多說了。對于非基本類型的Java對象，其大小就值得商榷。
在Java中，一個空Object對象的大小是8byte，這個大小只是保存堆中一個沒有任何屬性的對象的大小。看下面語句：
Object ob = new Object();
這樣在程序中完成了一個Java對象的生命，但是它所占的空間為：4byte+8byte。4byte是上面部分所說的Java棧中保存引用的所需要的空間。而那8byte則是Java堆中對象的信息。因為所有的Java非基本類型的對象都需要默認繼承Object對象，因此不論什么樣的Java對象，其大小都必須是大于8byte。
有了Object對象的大小，我們就可以計算其他對象的大小了。
Class NewObject {
int count;
boolean flag;
Object ob;
}
其大小為：空對象大小(8byte)+int大小(4byte)+Boolean大小(1byte)+空Object引用的大小(4byte)=17byte。但是因為Java在對對象內存分配時都是以8的整數倍來分，因此大于17byte的最接近8的整數倍的是24，因此此對象的大小為24byte。
這里需要注意一下基本類型的包裝類型的大小。因為這種包裝類型已經成為對象了，因此需要把他們作為對象來看待。包裝類型的大小至少是12byte（聲明一個空Object至少需要的空間），而且12byte沒有包含任何有效信息，同時，因為Java對象大小是8的整數倍，因此一個基本類型包裝類的大小至少是16byte。這個內存占用是很恐怖的，它是使用基本類型的N倍（N>2），有些類型的內存占用更是夸張（隨便想下就知道了）。因此，可能的話應盡量少使用包裝類。在JDK5.0以后，因為加入了自動類型裝換，因此，Java虛擬機會在存儲方面進行相應的優化。
引用類型
對象引用類型分為強引用、軟引用、弱引用和虛引用。
強引用:就是我們一般聲明對象是時虛擬機生成的引用，強引用環境下，垃圾回收時需要嚴格判斷當前對象是否被強引用，如果被強引用，則不會被垃圾回收
軟引用:軟引用一般被做為緩存來使用。與強引用的區別是，軟引用在垃圾回收時，虛擬機會根據當前系統的剩余內存來決定是否對軟引用進行回收。如果剩余內存比較緊張，則虛擬機會回收軟引用所引用的空間；如果剩余內存相對富裕，則不會進行回收。換句話說，虛擬機在發生OutOfMemory時，肯定是沒有軟引用存在的。
弱引用:弱引用與軟引用類似，都是作為緩存來使用。但與軟引用不同，弱引用在進行垃圾回收時，是一定會被回收掉的，因此其生命周期只存在于一個垃圾回收周期內。
強引用不用說，我們系統一般在使用時都是用的強引用。而“軟引用”和“弱引用”比較少見。他們一般被作為緩存使用，而且一般是在內存大小比較受限的情況下做為緩存。因為如果內存足夠大的話，可以直接使用強引用作為緩存即可，同時可控性更高。因而，他們常見的是被使用在桌面應用系統的緩存。
2.（三）-基本垃圾回收算法
可以從不同的的角度去劃分垃圾回收算法：
按照基本回收策略分
引用計數（Reference Counting）:
比較古老的回收算法。原理是此對象有一個引用，即增加一個計數，刪除一個引用則減少一個計數。垃圾回收時，只用收集計數為0的對象。此算法最致命的是無法處理循環引用的問題。
標記-清除（Mark-Sweep）
此算法執行分兩階段。第一階段從引用根節點開始標記所有被引用的對象，第二階段遍歷整個堆，把未標記的對象清除。此算法需要暫停整個應用，同時，會產生內存碎片。
復制（Copying）
此算法把內存空間劃為兩個相等的區域，每次只使用其中一個區域。垃圾回收時，遍歷當前使用區域，把正在使用中的對象復制到另外一個區域中。此算法每次只處理正在使用中的對象，因此復制成本比較小，同時復制過去以后還能進行相應的內存整理，不會出現“碎片”問題。當然，此算法的缺點也是很明顯的，就是需要兩倍內存空間。
標記-整理（Mark-Compact）
此算法結合了“標記-清除”和“復制”兩個算法的優點。也是分兩階段，第一階段從根節點開始標記所有被引用對象，第二階段遍歷整個堆，把清除未標記對象并且把存活對象“壓縮”到堆的其中一塊，按順序排放。此算法避免了“標記-清除”的碎片問題，同時也避免了“復制”算法的空間問題。
按分區對待的方
增量收集（Incremental Collecting）:實時垃圾回收算法，即：在應用進行的同時進行垃圾回收。不知道什么原因JDK5.0中的收集器沒有使用這種算法的。
分代收集（Generational Collecting）:基于對對象生命周期分析后得出的垃圾回收算法。把對象分為年青代、年老代、持久代，對不同生命周期的對象使用不同的算法（上述方式中的一個）進行回收。現在的垃圾回收器（從J2SE1.2開始）都是使用此算法的。
按系統線程分
串行收集:串行收集使用單線程處理所有垃圾回收工作，因為無需多線程交互，實現容易，而且效率比較高。但是，其局限性也比較明顯，即無法使用多處理器的優勢，所以此收集適合單處理器機器。當然，此收集器也可以用在小數據量（100M左右）情況下的多處理器機器上。
并行收集:并行收集使用多線程處理垃圾回收工作，因而速度快，效率高。而且理論上CPU數目越多，越能體現出并行收集器的優勢。
并發收集:相對于串行收集和并行收集而言，前面兩個在進行垃圾回收工作時，需要暫停整個運行環境，而只有垃圾回收程序在運行，因此，系統在垃圾回收時會有明顯的暫停，而且暫停時間會因為堆越大而越長。
3.（四）-垃圾回收面臨的問題
上面說到的“引用計數”法，通過統計控制生成對象和刪除對象時的引用數來判斷。垃圾回收程序收集計數為0的對象即可。但是這種方法無法解決循環引用。所以，后來實現的垃圾判斷算法中，都是從程序運行的根節點出發，遍歷整個對象引用，查找存活的對象。那么在這種方式的實現中，垃圾回收從哪兒開始的呢？即，從哪兒開始查找哪些對象是正在被當前系統使用的。上面分析的堆和棧的區別，其中棧是真正進行程序執行地方，所以要獲取哪些對象正在被使用，則需要從Java棧開始。同時，一個棧是與一個線程對應的，因此，如果有多個線程的話，則必須對這些線程對應的所有的棧進行檢查。
同時，除了棧外，還有系統運行時的寄存器等，也是存儲程序運行數據的。這樣，以棧或寄存器中的引用為起點，我們可以找到堆中的對象，又從這些對象找到對堆中其他對象的引用，這種引用逐步擴展，最終以null引用或者基本類型結束，這樣就形成了一顆以Java棧中引用所對應的對象為根節點的一顆對象樹，如果棧中有多個引用，則最終會形成多顆對象樹。在這些對象樹上的對象，都是當前系統運行所需要的對象，不能被垃圾回收。而其他剩余對象，則可以視為無法被引用到的對象，可以被當做垃圾進行回收。
因此，垃圾回收的起點是一些根對象（java棧, 靜態變量, 寄存器...）。而最簡單的Java棧就是Java程序執行的main函數。這種回收方式，也是上面提到的“標記-清除”的回收方式
如何處理碎片
由于不同Java對象存活時間是不一定的，因此，在程序運行一段時間以后，如果不進行內存整理，就會出現零散的內存碎片。碎片最直接的問題就是會導致無法分配大塊的內存空間，以及程序運行效率降低。所以，在上面提到的基本垃圾回收算法中，“復制”方式和“標記-整理”方式，都可以解決碎片的問題。
如何解決同時存在的對象創建和對象回收問題
垃圾回收線程是回收內存的，而程序運行線程則是消耗（或分配）內存的，一個回收內存，一個分配內存，從這點看，兩者是矛盾的。因此，在現有的垃圾回收方式中，要進行垃圾回收前，一般都需要暫停整個應用（即：暫停內存的分配），然后進行垃圾回收，回收完成后再繼續應用。這種實現方式是最直接，而且最有效的解決二者矛盾的方式。但是這種方式有一個很明顯的弊端，就是當堆空間持續增大時，垃圾回收的時間也將會相應的持續增大，對應應用暫停的時間也會相應的增大。一些對相應時間要求很高的應用，比如最大暫停時間要求是幾百毫秒，那么當堆空間大于幾個G時，就很有可能超過這個限制，在這種情況下，垃圾回收將會成為系統運行的一個瓶頸。為解決這種矛盾，有了并發垃圾回收算法，使用這種算法，垃圾回收線程與程序運行線程同時運行。在這種方式下，解決了暫停的問題，但是因為需要在新生成對象的同時又要回收對象，算法復雜性會大大增加，系統的處理能力也會相應降低，同時，“碎片”問題將會比較難解決。
為什么要分代
分代的垃圾回收策略，是基于這樣一個事實：不同的對象的生命周期是不一樣的。因此，不同生命周期的對象可以采取不同的收集方式，以便提高回收效率。
在Java程序運行的過程中，會產生大量的對象，其中有些對象是與業務信息相關，比如Http請求中的Session對象、線程、Socket連接，這類對象跟業務直接掛鉤，因此生命周期比較長。但是還有一些對象，主要是程序運行過程中生成的臨時變量，這些對象生命周期會比較短，比如：String對象，由于其不變類的特性，系統會產生大量的這些對象，有些對象甚至只用一次即可回收。
試想，在不進行對象存活時間區分的情況下，每次垃圾回收都是對整個堆空間進行回收，花費時間相對會長，同時，因為每次回收都需要遍歷所有存活對象，但實際上，對于生命周期長的對象而言，這種遍歷是沒有效果的，因為可能進行了很多次遍歷，但是他們依舊存在。因此，分代垃圾回收采用分治的思想，進行代的劃分，把不同生命周期的對象放在不同代上，不同代上采用最適合它的垃圾回收方式進行回收。
如何分代
如圖所示：虛擬機中的共劃分為三個代：年輕代（Young Generation）、年老點（Old Generation）和持久代（Permanent Generation）。其中持久代主要存放的是Java類的類信息，與垃圾收集要收集的Java對象關系不大。年輕代和年老代的劃分是對垃圾收集影響比較大的。
年輕代:
所有新生成的對象首先都是放在年輕代的。年輕代的目標就是盡可能快速的收集掉那些生命周期短的對象。年輕代分三個區。一個Eden區，兩個Survivor區(一般而言)。大部分對象在Eden區中生成。當Eden區滿時，還存活的對象將被復制到Survivor區（兩個中的一個），當這個Survivor區滿時，此區的存活對象將被復制到另外一個Survivor區，當這個Survivor去也滿了的時候，從第一個Survivor區復制過來的并且此時還存活的對象，將被復制“年老區(Tenured)”。需要注意，Survivor的兩個區是對稱的，沒先后關系，所以同一個區中可能同時存在從Eden復制過來 對象，和從前一個Survivor復制過來的對象，而復制到年老區的只有從第一個Survivor去過來的對象。而且，Survivor區總有一個是空的。同時，根據程序需要，Survivor區是可以配置為多個的（多于兩個），這樣可以增加對象在年輕代中的存在時間，減少被放到年老代的可能。
年老代:
在年輕代中經歷了N次垃圾回收后仍然存活的對象，就會被放到年老代中。因此，可以認為年老代中存放的都是一些生命周期較長的對象。
持久代:
用于存放靜態文件，如今Java類、方法等。持久代對垃圾回收沒有顯著影響，但是有些應用可能動態生成或者調用一些class，例如Hibernate等，在這種時候需要設置一個比較大的持久代空間來存放這些運行過程中新增的類。持久代大小通過-XX:MaxPermSize=<N>進行設置。
什么情況下觸發垃圾回收
由于對象進行了分代處理，因此垃圾回收區域、時間也不一樣。GC有兩種類型：Scavenge GC和Full GC。
Scavenge GC
一般情況下，當新對象生成，并且在Eden申請空間失敗時，就會觸發Scavenge GC，對Eden區域進行GC，清除非存活對象，并且把尚且存活的對象移動到Survivor區。然后整理Survivor的兩個區。這種方式的GC是對年輕代的Eden區進行，不會影響到年老代。因為大部分對象都是從Eden區開始的，同時Eden區不會分配的很大，所以Eden區的GC會頻繁進行。因而，一般在這里需要使用速度快、效率高的算法，使Eden去能盡快空閑出來。
Full GC
對整個堆進行整理，包括Young、Tenured和Perm。Full GC因為需要對整個對進行回收，所以比Scavenge GC要慢，因此應該盡可能減少Full GC的次數。在對JVM調優的過程中，很大一部分工作就是對于FullGC的調節。有如下原因可能導致Full GC：
· 年老代（Tenured）被寫滿
· 持久代（Perm）被寫滿
· System.gc()被顯示調用
·上一次GC之后Heap的各域分配策略動態變化
5.（六）-分代垃圾回收詳述2
選擇合適的垃圾收集算法
串行收集器
用單線程處理所有垃圾回收工作，因為無需多線程交互，所以效率比較高。但是，也無法使用多處理器的優勢，所以此收集器適合單處理器機器。當然，此收集器也可以用在小數據量（100M左右）情況下的多處理器機器上。可以使用-XX:+UseSerialGC打開。
并行收集器
對年輕代進行并行垃圾回收，因此可以減少垃圾回收時間。一般在多線程多處理器機器上使用。使用-XX:+UseParallelGC.打開。并行收集器在J2SE5.0第六6更新上引入，在Java SE6.0中進行了增強--可以對年老代進行并行收集。如果年老代不使用并發收集的話，默認是使用單線程進行垃圾回收，因此會制約擴展能力。使用-XX:+UseParallelOldGC打開。
使用-XX:ParallelGCThreads=<N>設置并行垃圾回收的線程數。此值可以設置與機器處理器數量相等。
此收集器可以進行如下配置：
最大垃圾回收暫停:指定垃圾回收時的最長暫停時間，通過-XX:MaxGCPauseMillis=<N>指定。<N>為毫秒.如果指定了此值的話，堆大小和垃圾回收相關參數會進行調整以達到指定值。設定此值可能會減少應用的吞吐量。
吞吐量:吞吐量為垃圾回收時間與非垃圾回收時間的比值，通過-XX:GCTimeRatio=<N>來設定，公式為1/（1+N）。例如，-XX:GCTimeRatio=19時，表示5%的時間用于垃圾回收。默認情況為99，即1%的時間用于垃圾回收。
并發收集器
可以保證大部分工作都并發進行（應用不停止），垃圾回收只暫停很少的時間，此收集器適合對響應時間要求比較高的中、大規模應用。使用-XX:+UseConcMarkSweepGC打開。
并發收集器主要減少年老代的暫停時間，他在應用不停止的情況下使用獨立的垃圾回收線程，跟蹤可達對象。在每個年老代垃圾回收周期中，在收集初期并發收集器 會對整個應用進行簡短的暫停，在收集中還會再暫停一次。第二次暫停會比第一次稍長，在此過程中多個線程同時進行垃圾回收工作。
并發收集器使用處理器換來短暫的停頓時間。在一個N個處理器的系統上，并發收集部分使用K/N個可用處理器進行回收，一般情況下1<=K<=N/4。
在只有一個處理器的主機上使用并發收集器，設置為incremental mode模式也可獲得較短的停頓時間。
浮動垃圾：由于在應用運行的同時進行垃圾回收，所以有些垃圾可能在垃圾回收進行完成時產生，這樣就造成了“Floating Garbage”，這些垃圾需要在下次垃圾回收周期時才能回收掉。所以，并發收集器一般需要20%的預留空間用于這些浮動垃圾。
Concurrent Mode Failure：并發收集器在應用運行時進行收集，所以需要保證堆在垃圾回收的這段時間有足夠的空間供程序使用，否則，垃圾回收還未完成，堆空間先滿了。這種情況下將會發生“并發模式失敗”，此時整個應用將會暫停，進行垃圾回收。
啟動并發收集器：因為并發收集在應用運行時進行收集，所以必須保證收集完成之前有足夠的內存空間供程序使用，否則會出現“Concurrent Mode Failure”。通過設置-XX:CMSInitiatingOccupancyFraction=<N>指定還有多少剩余堆時開始執行并發收集
小結
串行處理器：
--適用情況：數據量比較小（100M左右）；單處理器下并且對響應時間無要求的應用。
--缺點：只能用于小型應用
并行處理器：
--適用情況：“對吞吐量有高要求”，多CPU、對應用響應時間無要求的中、大型應用。舉例：后臺處理、科學計算。
--缺點：垃圾收集過程中應用響應時間可能加長
并發處理器：
--適用情況：“對響應時間有高要求”，多CPU、對應用響應時間有較高要求的中、大型應用。舉例：Web服務器/應用服務器、電信交換、集成開發環境。
