深入理解 Java 中的 try-with-resource

梦里梦外; 2021-09-29 23:52 215阅读 0赞

**背景**  
众所周知，所有被打开的系统资源，比如流，文件或者插座连接等，都需要被开发者手动关闭，否则随着程序的不断运行，资源泄露将会累积成重大的生产事故。

在Java的的江湖中，存在着一种名为最后的功夫，它可以保证当你习武走火入魔之时，还可以做一些自救的操作。在远古时代，处理资源关闭的代码通常写在最后块中然而，如果你同时打开了多个资源，那么将会出现噩梦般的场景：

public  class  Demo  {
         public  static  void  main （String [] args）  {
            BufferedInputStream bin = null ;
            BufferedOutputStream bout = null ;
            尝试 {
                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（）;
                    }
                    finally {
                         if（bout！= null）{
                             try {
                                bout.close（）;
                            }
                            catch（IOException e）{
                                e.printStackTrace（）;
                            }
                        }
                    }
                }
            }
        }
    }

哦，我的上帝!!! 关闭资源的代码竟然比业务代码还要多 !!!这是因为，我们不仅需要关闭BufferedInputStream，还需要保证如果关闭BufferedInputStream时出现了异常， BufferedOutputStream也要能被正确地关闭。所以我们不得不借助终于中嵌套终于大法。可以想到，打开的资源越多，终于中嵌套的将会越深！

更为可恶的是，Python的程序员面对这个问题，竟然微微一笑很倾城地说：“这个我们一点都不用考虑的嘞〜”：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70]  
但是兄弟莫慌！我们可以利用Java 1.7中新增的try-with-resource语法糖来打开资源，而无需码农民自己书写资源来关闭代码。妈妈再也不用担心我把手写断掉了！我们用尝试 - 用资源来改写刚才的例子：

public  class  TryWithResource  {
         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（）;
            }
        }
    }

是不是很简单？是不是很刺激？再也不用被Python的程序员鄙视了！好了，下面将会详细讲解其实现原理以及内部机制。  
**实践**  
为了能够配合尝试，有资源，必须资源实现AutoClosable接口该接口的实现类需要重写。  
close方法：

public  class  Connection  实现 AutoCloseable  {
         public  void  sendData （）  {
            System.out.println（“正在发送数据”）;
        }
        @Override 
        public  void  close （） 抛出异常 {
            System.out.println（“正在关闭连接”）;
        }
    }

调用类：

public  class  TryWithResource  {
         public  static  void  main （String [] args）  {
             try（Connection conn = new Connection（））{
                conn.sendData（）;
            }
            catch（例外e）{
                e.printStackTrace（）;
            }
        }
    }

运行结果：  
正在发送数据  
正在关闭连接

**原理**  
那么这个是怎么做到的呢我相信聪明的你们一定已经猜到了，其实，这一切都是编译器大神搞的鬼我们反编译刚才例子的类文件？：

public  class  TryWithResource  {
         public  TryWithResource （）  {
        }
        public  static  void  main （String [] args）  {
             try {
                连接e = new Connection（）;
                可抛出的 var2 = null ;
                尝试 {
                    e.sendData（）;
                } catch（Throwable var12）{
                    var2 = var12;
                    throw var12;
                } finally {
                     if（e！= null）{
                         if（var2！= null）{
                             try {
                                e.close（）;
                            } catch（Throwable var11）{
                                var2.addSuppressed（var11）;
                            }
                        } else {
                            e.close（）;
                        }
                    }
                }
            } catch（Exception var14）{
                var14.printStackTrace（）;
            }
        }
    }

看到没，在第15〜27行，编译器自动帮我们生成了最终块，并且在里面调用了资源的接近方法，所以例子中的接近方法会在运行的时候被执行。  
**异常屏蔽**  
我相信，细心的你们肯定又发现了，刚才反编译的代码（第21行）远古比时代写的代码多了一个addSuppressed为了了解这段代码的用意，我们稍微修改一下刚才的例子：我们将刚才的代码改回远古时代手动关闭异常的方式，在并且sendData状语从句：close方法中抛出异常：

public  class  Connection  实现 AutoCloseable  {
         public  void  sendData （） throws Exception {
             throw  new Exception（“send data”）;
        }
        @Override 
        public  void  close （） 抛出异常 {
             throw  new MyException（“close”）;
        }
    }

修改main方法：

public  class  TryWithResource  {
         public  static  void  main （String [] args）  {
             try {
                测试（）;
            }
            catch（例外e）{
                e.printStackTrace（）;
            }
        }
        private  static  void  test （） 抛出异常 {
            连接conn = null ;
            尝试 {
                conn = new Connection（）;
                conn.sendData（）;
            }
            finally {
                 if（conn！= null）{
                    conn.close（）;
                }
            }
        }
    }

运行后发现：  
基本.exception .MyException：靠近  
在 基本.exception ■连接.close（连接的.java ：10）  
在 基本.exception .TryWithResource 。测试（TryWithResource 的.java ：82）  
在 基本.exception .TryWithResource 。主要（TryWithResource 的.java ： 7）  
…  
好的，问题来了，由于我们一次只能抛出一个异常，所以在最上层看到的是最后一个抛出的异常-就是也。close方法抛出的MyException，而sendData抛出的Exception。被忽略了这就是所谓的异常屏蔽。由于异常信息的丢失，异常屏蔽可能会导致某些错误变得极其难以发现，程序员们不得不加班加点地找错误，如此毒瘤，怎能不除！幸好，为了解决这个问题，从Java 1.7开始，大佬们为Throwable类新增了addSuppressed方法，支持将一个异常附加到另一个异常身上，从而避免异常屏蔽。那么被屏蔽的异常信息会通过怎样的格式输出呢？我们再运行一遍刚才用试穿与资源包裹的主要方法：

的java .lang .Exception：发送 数据
    在 基本.exception ■连接.sendData（连接的.java ：5）
    在 基本.exception .TryWithResource 。主要（TryWithResource 的.java ：14）
    ......
    抑制：基本.exception .MyException：关闭
    	在 基本.exception ■连接.close（连接的.java ：10）
    	在 基本.exception .TryWithResource 。主要（TryWithResource 的.java ：15） 
    	... 5 更多
    	可以看到，信息异常多中了一个Suppressed的提示，告诉我们这个异常其实由两个异常组成，MyException是被禁止的异常。可喜可贺！

**后记（一个小问题）**  
在使用试穿与资源的过程中，需要一定了解资源的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的装饰器。由于尝试，与资源的特性，实际编译之后的代码会在后面带上最后代码块，并且在里面调用fin.close（）方法和out.close（）方法我们再来看。GZIPOutputStream类的接近方法：

public  void  close （） 抛出 IOException {
         if（！closed）{
            完（）;
            if（usesDefaultDeflater）
                防守（）;
            out.close（）;
            closed = true ;
        }
    }

我们可以看到，从实际上变量代表的的英文被装饰的FileOutputStream类。在调用出来的变量close方法之前，GZIPOutputStream还做了finish操作，操作该继续还会往FileOutputStream中写压缩信息，此时如果出现异常，则会out.close()方法被略过，然而这个才是最底层的资源关闭方法。正确的做法是应该在尝试，用资源中单独声明最底层的资源，对应保证的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（）;
            }
        }
    }

compile-由于会器自动生成fout.close()的代码，这样肯定能够保证真正的流被关闭。  
**附**  
原文地址：[http://www.kissyu.org/2016/10/06/深入理解Java try-with-resource/][http_www.kissyu.org_2016_10_06_Java try-with-resource]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70]: /images/20210923/b96b67524b5f479d8d48a009b9959bd2.png
[http_www.kissyu.org_2016_10_06_Java try-with-resource]: http://www.kissyu.org/2016/10/06/%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3Java%20try-with-resource/