UDN-企业互联网技术人气社区

板块导航

浏览  : 1404
回复  : 0

[讨论交流] 深入理解 Java 中的 try-with-resource

[复制链接]
哥屋恩的头像 楼主
发表于 2016-10-29 19:24:33 | 显示全部楼层 |阅读模式
  子曾经曰过:所有的炒冷饭都是温故而知新。

  背景

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

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

  1.   public class Demo {

  2.   public static void main(String[] args) {

  3.   BufferedInputStream bin = null;

  4.   BufferedOutputStream bout = null;

  5.   try {

  6.   bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));

  7.   bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")));

  8.   int b;

  9.   while ((b = bin.read()) != -1) {

  10.   bout.write(b);

  11.   }

  12.   }

  13.   catch (IOException e) {

  14.   e.printStackTrace();

  15.   }

  16.   finally {

  17.   if (bin != null) {

  18.   try {

  19.   bin.close();

  20.   }

  21.   catch (IOException e) {

  22.   e.printStackTrace();

  23.   }

  24.   finally {

  25.   if (bout != null) {

  26.   try {

  27.   bout.close();

  28.   }

  29.   catch (IOException e) {

  30.   e.printStackTrace();

  31.   }

  32.   }

  33.   }

  34.   }

  35.   }

  36.   }

  37.   }
复制代码


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

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

8.png


  但是兄弟莫慌!我们可以利用Java 1.7中新增的try-with-resource语法糖来打开资源,而无需码农们自己书写资源来关闭代码。妈妈再也不用担心我把手写断掉了!我们用try-with-resource来改写刚才的例子:

  1.   public class TryWithResource {

  2.   public static void main(String[] args) {

  3.   try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));

  4.   BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))) {

  5.   int b;

  6.   while ((b = bin.read()) != -1) {

  7.   bout.write(b);

  8.   }

  9.   }

  10.   catch (IOException e) {

  11.   e.printStackTrace();

  12.   }

  13.   }

  14.   }
复制代码


  是不是很简单?是不是很刺激?再也不用被Python程序员鄙视了!好了,下面将会详细讲解其实现原理以及内部机制。

  动手实践

  为了能够配合try-with-resource,资源必须实现AutoClosable接口。该接口的实现类需要重写close方法:

  1.   public class Connection implements AutoCloseable {

  2.   public void sendData() {

  3.   System.out.println("正在发送数据");

  4.   }

  5.   @Override

  6.   public void close() throws Exception {

  7.   System.out.println("正在关闭连接");

  8.   }

  9.   }
复制代码


  调用类:

  1.   public class TryWithResource {

  2.   public static void main(String[] args) {

  3.   try (Connection conn = new Connection()) {

  4.   conn.sendData();

  5.   }

  6.   catch (Exception e) {

  7.   e.printStackTrace();

  8.   }

  9.   }

  10.   }
复制代码


  运行后输出结果:

  1.   正在发送数据

  2.   正在关闭连接
复制代码


  通过结果我们可以看到,close方法被自动调用了。

  原理

  那么这个是怎么做到的呢?我相信聪明的你们一定已经猜到了,其实,这一切都是编译器大神搞的鬼。我们反编译刚才例子的class文件:

  1.   public class TryWithResource {

  2.   public TryWithResource() {

  3.   }

  4.   public static void main(String[] args) {

  5.   try {

  6.   Connection e = new Connection();

  7.   Throwable var2 = null;

  8.   try {

  9.   e.sendData();

  10.   } catch (Throwable var12) {

  11.   var2 = var12;

  12.   throw var12;

  13.   } finally {

  14.   if(e != null) {

  15.   if(var2 != null) {

  16.   try {

  17.   e.close();

  18.   } catch (Throwable var11) {

  19.   var2.addSuppressed(var11);

  20.   }

  21.   } else {

  22.   e.close();

  23.   }

  24.   }

  25.   }

  26.   } catch (Exception var14) {

  27.   var14.printStackTrace();

  28.   }

  29.   }

  30.   }
复制代码


  看到没,在第15~27行,编译器自动帮我们生成了finally块,并且在里面调用了资源的close方法,所以例子中的close方法会在运行的时候被执行。

  异常屏蔽

  我相信,细心的你们肯定又发现了,刚才反编译的代码(第21行)比远古时代写的代码多了一个addSuppressed。为了了解这段代码的用意,我们稍微修改一下刚才的例子:我们将刚才的代码改回远古时代手动关闭异常的方式,并且在sendData和close方法中抛出异常:

  1.   public class Connection implements AutoCloseable {

  2.   public void sendData() throws Exception {

  3.   throw new Exception("send data");

  4.   }

  5.   @Override

  6.   public void close() throws Exception {

  7.   throw new MyException("close");

  8.   }

  9.   }
复制代码


  修改main方法:

 
  1.  public class TryWithResource {

  2.   public static void main(String[] args) {

  3.   try {

  4.   test();

  5.   }

  6.   catch (Exception e) {

  7.   e.printStackTrace();

  8.   }

  9.   }

  10.   private static void test() throws Exception {

  11.   Connection conn = null;

  12.   try {

  13.   conn = new Connection();

  14.   conn.sendData();

  15.   }

  16.   finally {

  17.   if (conn != null) {

  18.   conn.close();

  19.   }

  20.   }

  21.   }

  22.   }
复制代码


  运行之后我们发现:

  1.   basic.exception.MyException: close

  2.   at basic.exception.Connection.close(Connection.java:10)

  3.   at basic.exception.TryWithResource.test(TryWithResource.java:82)

  4.   at basic.exception.TryWithResource.main(TryWithResource.java:7)

  5.   ......
复制代码


  好的,问题来了,由于我们一次只能抛出一个异常,所以在最上层看到的是最后一个抛出的异常——也就是close方法抛出的MyException,而sendData抛出的Exception被忽略了。这就是所谓的异常屏蔽。由于异常信息的丢失,异常屏蔽可能会导致某些bug变得极其难以发现,程序员们不得不加班加点地找bug,如此毒瘤,怎能不除!幸好,为了解决这个问题,从Java 1.7开始,大佬们为Throwable类新增了addSuppressed方法,支持将一个异常附加到另一个异常身上,从而避免异常屏蔽。那么被屏蔽的异常信息会通过怎样的格式输出呢?我们再运行一遍刚才用try-with-resource包裹的main方法:

  1.   java.lang.Exception: send data

  2.   at basic.exception.Connection.sendData(Connection.java:5)

  3.   at basic.exception.TryWithResource.main(TryWithResource.java:14)

  4.   ......

  5.   Suppressed: basic.exception.MyException: close

  6.   at basic.exception.Connection.close(Connection.java:10)

  7.   at basic.exception.TryWithResource.main(TryWithResource.java:15)

  8.   ... 5 more
复制代码


  可以看到,异常信息中多了一个Suppressed的提示,告诉我们这个异常其实由两个异常组成,MyException是被Suppressed的异常。可喜可贺!

  一个小问题

  在使用try-with-resource的过程中,一定需要了解资源的close方法内部的实现逻辑。否则还是可能会导致资源泄露。

  举个例子,在Java BIO中采用了大量的装饰器模式。当调用装饰器的close方法时,本质上是调用了装饰器内部包裹的流的close方法。比如:

  1.   public class TryWithResource {

  2.   public static void main(String[] args) {

  3.   try (FileInputStream fin = new FileInputStream(new File("input.txt"));

  4.   GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(new File("out.txt")))) {

  5.   byte[] buffer = new byte[4096];

  6.   int read;

  7.   while ((read = fin.read(buffer)) != -1) {

  8.   out.write(buffer, 0, read);

  9.   }

  10.   }

  11.   catch (IOException e) {

  12.   e.printStackTrace();

  13.   }

  14.   }

  15.   }
复制代码


  在上述代码中,我们从FileInputStream中读取字节,并且写入到GZIPOutputStream中。GZIPOutputStream实际上是FileOutputStream的装饰器。由于try-with-resource的特性,实际编译之后的代码会在后面带上finally代码块,并且在里面调用fin.close()方法和out.close()方法。我们再来看GZIPOutputStream类的close方法:

  1.   public void close() throws IOException {

  2.   if (!closed) {

  3.   finish();

  4.   if (usesDefaultDeflater)

  5.   def.end();

  6.   out.close();

  7.   closed = true;

  8.   }

  9.   }
复制代码


  我们可以看到,out变量实际上代表的是被装饰的FileOutputStream类。在调用out变量的close方法之前,GZIPOutputStream还做了finish操作,该操作还会继续往FileOutputStream中写压缩信息,此时如果出现异常,则会out.close()方法被略过,然而这个才是最底层的资源关闭方法。正确的做法是应该在try-with-resource中单独声明最底层的资源,保证对应的close方法一定能够被调用。在刚才的例子中,我们需要单独声明每个FileInputStream以及FileOutputStream:

  1.   public class TryWithResource {

  2.   public static void main(String[] args) {

  3.   try (FileInputStream fin = new FileInputStream(new File("input.txt"));

  4.   FileOutputStream fout = new FileOutputStream(new File("out.txt"));

  5.   GZIPOutputStream out = new GZIPOutputStream(fout)) {

  6.   byte[] buffer = new byte[4096];

  7.   int read;

  8.   while ((read = fin.read(buffer)) != -1) {

  9.   out.write(buffer, 0, read);

  10.   }

  11.   }

  12.   catch (IOException e) {

  13.   e.printStackTrace();

  14.   }

  15.   }

  16.   }
复制代码


  由于编译器会自动生成fout.close()的代码,这样肯定能够保证真正的流被关闭。

  总结

  怎么样,是不是很简单呢,如果学会了话

7.jpg


原文作者:佚名  来源:开发者头条

相关帖子

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

关于我们
联系我们
  • 电话:010-86393388
  • 邮件:udn@yonyou.com
  • 地址:北京市海淀区北清路68号
移动客户端下载
关注我们
  • 微信公众号:yonyouudn
  • 扫描右侧二维码关注我们
  • 专注企业互联网的技术社区
版权所有:用友网络科技股份有限公司82041 京ICP备05007539号-11 京公网网备安1101080209224 Powered by Discuz!
快速回复 返回列表 返回顶部