為什么推薦大家優先使用 try-with-resources 而非 try-finally

作者：了不起 2024-09-24 08:18:13

在處理必須關閉的資源時，使用try-with-resources?語句替代try-catch-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方法內部的實現邏輯，避免資源泄露，服務宕機！

責任編輯：武曉燕來源： Java極客技術

代碼語句資源