為什么推薦大家優先使用 try-with-resources 而非 try-finally
一、背景介紹
try-with-resources是 JDK 7 中引入的一個新的異常處理機制，它能讓開發人員不用顯式的釋放try-catch語句塊中使用的資源。
比如，我們以文件資源拷貝為示例，大家所熟悉的try-catch-finally寫法如下：
public class ResourceTest1 {
public static void main(String[] args) {
BufferedInputStream bin = null;
BufferedOutputStream bout = null;
try {
bin = new BufferedInputStream(new FileInputStream(new File( "test.txt")));
bout = new BufferedOutputStream(new FileOutputStream(new File( "out.txt")));
int b;
while ((b = bin.read()) != -1) {
bout.write(b);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//關閉文件流
if (bin != null) {
try {
bin.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bout != null) {
try {
bout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}我們現在將其改成使用try-with-resources編程方式，你會驚奇的發現只需要簡單的幾行代碼就可以搞定，不用顯式關閉資源，方式如下：
public class ResourceTest2 {
public static void main(String[] args) {
try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))) {
int b;
while ((b = bin.read()) != -1) {
bout.write(b);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}在 JDK7 之前，在處理必須關閉的資源時，開發人員必須要牢記在try-catch語句中使用finally執行關閉資源的方法，否則隨著程序不斷運行，資源泄露將會累計成重大的生產事故，如果你的程序中同時打開了多個資源，你會驚奇的發，關閉資源的代碼竟然比業務代碼還要多，使得代碼更加難以清晰的閱讀和管理。
因此在這樣的背景下，try-with-resources由此誕生，它的設計初衷就是旨在減輕開發人員釋放try塊中使用的資源負擔。
習慣了try-catch-finally寫法的同學，可能會發出疑問，是不是所有涉及到資源的操作都可以用try-with-resources編程？使用這種編程方式有沒有坑？如果有坑，使用的時候哪些地方應該需要注意呢？....
好吧，廢話也不多說了，今天我們就一起來看看try-with-resources編程原理。
二、實踐解說
try-with-resources語句能確保每個資源在語句結束時被關閉，但是有一個前提條件，那就是這個資源必須實現了java.lang.AutoCloseable接口，才可以被執行關閉。
try-with-resources編程模式中，無需開發人員顯式關閉資源的前提是，這個資源必須實現java.lang.AutoCloseable接口，并且重寫close方法，否則無法在try-with-resources中進行聲明變量。
下面我們可以關閉單個資源為例，代碼如下：
public class TryResourceDemo implements AutoCloseable {
public void doSomething(){
System.out.println("do something");
}
@Override
public void close() throws Exception {
System.out.println("resource is closed");
}
}public class TryResourceTest {
public static void main(String[] args) {
try(TryResourceDemo res = new TryResourceDemo()) {
res.doSomething();
} catch(Exception ex) {
ex.printStackTrace();
}
}
}運行結果如下：
do something
resource is closed可以很清晰的看到，close方法被調用了！
下面我們再打開反編譯后的TryResourceTest.class文件代碼，你會驚奇發現，編譯器自動給代碼加上了finally方法，并且會調用close方法，將資源關閉！
public class TryResourceTest {
public static void main(String[] args) {
try {
TryResourceDemo res = new TryResourceDemo();
Throwable var2 = null;
try {
res.doSomething();
} catch (Throwable var12) {
var2 = var12;
throw var12;
} finally {
if (res != null) {
if (var2 != null) {
try {
res.close();
} catch (Throwable var11) {
var2.addSuppressed(var11);
}
} else {
res.close();
}
}
}
} catch (Exception var14) {
var14.printStackTrace();
}
}
}也就是說，使用try-with-resources編程，其實是編譯器顯式的給代碼了添加finally方法，省去開發人員手動關閉資源的操作！
三、資源關閉順序
上面我們只介紹了關閉單個資源的場景，假如有多個資源時，try-with-resources是如何關閉的呢？
下面還是舉例看結果。
public class TryResourceDemo1 implements AutoCloseable {
public void doSomething(){
System.out.println("do something 1");
}
@Override
public void close() throws Exception {
System.out.println("resource 1 is closed");
}
}public class TryResourceDemo2 implements AutoCloseable {
public void doSomething(){
System.out.println("do something 2");
}
@Override
public void close() throws Exception {
System.out.println("resource 2 is closed");
}
}public class TryResourceDemoTest {
public static void main(String[] args) {
try(TryResourceDemo1 demo1 = new TryResourceDemo1();
TryResourceDemo2 demo2 = new TryResourceDemo2()) {
System.out.println("do...");
demo1.doSomething();
demo2.doSomething();
} catch(Exception ex) {
ex.printStackTrace();
}
}
}運行結果如下：
do...
do something 1
do something 2
resource 2 is closed
resource 1 is closed從結果上可以看出，try語句中越是最后使用的資源，越是最早被關閉。
關于這一點，大家可以從反編譯的代碼中找到原理！
四、異常處理機制
正常的情況下，try語句結束時會關閉相關的資源，假如語句內部執行時發生異常，同時我們又顯式的調用了finally方法，執行的順序又是怎樣的呢？
下面繼續舉例看結果。
public class TryThrowResourceDemoTest {
public static void main(String[] args) {
AutoCloseable obj1 = null;
AutoCloseable obj2 = null;
try (TryResourceDemo1 demo1 = new TryResourceDemo1();
TryResourceDemo2 demo2 = new TryResourceDemo2();) {
System.out.println("do...");
obj1 = demo1;
System.out.println(1 / 0);
obj2 = demo2;
System.out.println("over...");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
System.out.println("before finally close");
if (obj1 != null) {
obj1.close();
}
if (obj2 != null) {
obj2.close();
}
System.out.println("after finally close");
} catch (Exception e) {
e.printStackTrace();
}
}
}
}運行結果如下：
do...
resource 2 is closed
resource 1 is closed
before finally close
resource 1 is closed
after finally close
java.lang.ArithmeticException: / by zero
at com.example.java.trywithresources.a.TryThrowResourceDemoTest.main(TryThrowResourceDemoTest.java:18)可以很清晰的看到，可以得出如下結論：
- 1.只要實現了AutoCloseable接口的類，并且在try里聲明了對象變量，在try結束后，不管是否發生異常，close方法都會被調用
- 2.其次，在try里越晚聲明的對象，會越早被close掉
- 3.try結束后自動調用的close方法，這個動作會早于finally里調用的方法
五、壓制異常處理
大部分情況，我們通常不會擔心資源的close會發生異常，現在假設如果try里聲明的資源對象，當執行close方法拋異常時，他們的執行順序又是怎樣的呢？我們又如何獲取這種異常呢？
還是眼見為實，下面以舉例看結果。
public class TryThrowableResourceDemo1 implements AutoCloseable {
public void doSomething(){
System.out.println("do something 1");
throw new NullPointerException("TryThrowableResourceDemo1: doSomething() NullPointerException");
}
@Override
public void close() throws Exception {
System.out.println("TryThrowableResourceDemo1 is closed");
throw new NullPointerException("TryThrowableResourceDemo1: close() NullPointerException");
}
}public class TryThrowableResourceDemo2 implements AutoCloseable {
public void doSomething(){
System.out.println("do something 2");
throw new NullPointerException("TryThrowableResourceDemo2: doSomething() NullPointerException");
}
@Override
public void close() throws Exception {
System.out.println("TryThrowableResourceDemo2 is closed");
throw new NullPointerException("TryThrowableResourceDemo2: close() NullPointerException");
}
}public class TryThrowableResourceDemoTest {
public static void main(String[] args) {
try (TryThrowableResourceDemo1 demo1 = new TryThrowableResourceDemo1();
TryThrowableResourceDemo2 demo2 = new TryThrowableResourceDemo2()) {
System.out.println("do...");
demo1.doSomething();
demo2.doSomething();
} catch (Exception e) {
System.out.println("gobal: exception");
System.out.println(e.getMessage());
Throwable[] suppressed = e.getSuppressed();
for (int i = 0; i < suppressed.length; i++){
System.out.println(suppressed[i].getMessage());
}
}
}
}運行結果如下：
do...
do something 1
TryThrowableResourceDemo2 is closed
TryThrowableResourceDemo1 is closed
gobal: exception
TryThrowableResourceDemo1: doSomething() NullPointerException
TryThrowableResourceDemo2: close() NullPointerException
TryThrowableResourceDemo1: close() NullPointerException從運行結果我們可以很清晰的看到，對于try語句塊內的異常，我們可以通過e.getMessage()獲取，對于close()方法拋出的異常，其實編譯器對這部分的異常進行特殊處理，將其放入到集合數組中了，因此我們需要通過e.getSuppressed()方法來獲取。
具體反編譯后的代碼如下：
public class TryThrowableResourceDemoTest {
public static void main(String[] args) {
try {
TryThrowableResourceDemo1 demo1 = new TryThrowableResourceDemo1();
Throwable var34 = null;
try {
TryThrowableResourceDemo2 demo2 = new TryThrowableResourceDemo2();
Throwable var4 = null;
try {
System.out.println("do...");
demo1.doSomething();
demo2.doSomething();
} catch (Throwable var29) {
var4 = var29;
throw var29;
} finally {
if (demo2 != null) {
if (var4 != null) {
try {
demo2.close();
} catch (Throwable var28) {
var4.addSuppressed(var28);
}
} else {
demo2.close();
}
}
}
} catch (Throwable var31) {
var34 = var31;
throw var31;
} finally {
if (demo1 != null) {
if (var34 != null) {
try {
demo1.close();
} catch (Throwable var27) {
var34.addSuppressed(var27);
}
} else {
demo1.close();
}
}
}
} catch (Exception var33) {
System.out.println("gobal: exception");
System.out.println(var33.getMessage());
Throwable[] suppressed = var33.getSuppressed();
for(int i = 0; i < suppressed.length; ++i) {
System.out.println(suppressed[i].getMessage());
}
}
}
}六、關閉資源的坑
在實際的使用中，不管是使用try-with-resource編程還是使用try-catch-finally編程，一定需要了解資源的close方法內部的實現邏輯，否則還是可能會導致資源泄露。
舉個例子，在 Java BIO 中采用了大量的裝飾器模式。當調用裝飾器的 close 方法時，本質上是調用了裝飾器包裝的流對象的 close 方法。比如：
public class TryWithResource {
public static void main(String[] args) {
try (FileInputStream fin = new FileInputStream(new File("input.txt"));
GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(new File("out.txt")))) {
byte[] buffer = new byte[4096];
int read;
while ((read = fin.read(buffer)) != -1) {
out.write(buffer, 0, read);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}在上述代碼中，我們從FileInputStream中讀取字節，并且寫入到GZIPOutputStream中。GZIPOutputStream實際上是FileOutputStream的裝飾器。
由于try-with-resource的特性，實際編譯之后的代碼會在后面帶上finally代碼塊，并且在里面調用fin.close()方法和out.close()方法。
我們再來看GZIPOutputStream類的close方法。
public void close() throws IOException {
if (!closed) {
finish();
if (usesDefaultDeflater)
def.end();
out.close();
closed = true;
}
}在調用out變量的close方法之前，GZIPOutputStream還做了finish操作，該操作還會繼續往FileOutputStream中寫壓縮信息，此時如果出現異常，則out.close()方法會被略過，而out變量實際上代表的是被裝飾的FileOutputStream類，這個才是最底層的資源關閉方法。
正確的做法應該是在try-with-resource中單獨聲明最底層的資源，保證對應的close方法一定能夠被調用。在剛才的例子中，我們需要單獨聲明每個FileInputStream以及FileOutputStream，改成如下方式：
public class TryWithResource {
public static void main(String[] args) {
try (FileInputStream fin = new FileInputStream(new File("input.txt"));
FileOutputStream fout = new FileOutputStream(new File("out.txt"));
GZIPOutputStream out = new GZIPOutputStream(fout)) {
byte[] buffer = new byte[4096];
int read;
while ((read = fin.read(buffer)) != -1) {
out.write(buffer, 0, read);
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}編譯器會自動生成fout.close()的代碼，這樣肯定能夠保證真正的流被關閉。
七、小結
在處理必須關閉的資源時，使用try-with-resources語句替代try-catch-finally語句，你會驚奇的發現，編寫的代碼更簡潔，更清晰，同時也省去了手動顯式釋放資源的煩惱。
因此在實際編程過程中，推薦大家采用這種方式編寫，同時要關注close方法內部的實現邏輯，避免資源泄露，服務宕機！
