背景

try-finally 这个语句想必做java的同学都不陌生吧，每当我们有关闭资源的需求我们都会使用到try-finally这个语句，比如我们在使用锁的时候，无论是本地的可重入锁还是分布式锁都会有下面类似的结构代码，我们会在finally里面进行unlock，用于强制解锁：

    Lock lock = new ReentrantLock();
    lock.lock();
    try{
        // doSometing
    }finally {
        lock.unlock();
    }

或者我们使用java的文件流读取或者写入文件的时候，我们也会在finally中强制关闭文件流，防止资源泄漏。

    InputStream inputStream = new FileInputStream("file");
    try {
        System.out.println(inputStream.read(new byte[4]));
    }finally {
        inputStream.close();
    }

其实乍一看 这样的写法应该没什么问题，但是如果我们出现了多个资源需要关闭我们应该怎么写呢？最常见的写法如下：

InputStream inputStream = new FileInputStream("file");
    OutputStream outStream = new FileOutputStream("file1");

    try {
        System.out.println(inputStream.read(new byte[4]));
        outStream.write(new byte[4]);
    }finally {
        inputStream.close();
        outStream.close();
    }

我们在外面定义了两个资源，然后在finally里面依次对这两个资源进行关闭，这个写法在我最开始写java的时候对文件流和数据库连接池做close的时候一些教学的文章都是这么教学的，那么这个哪里有问题呢？问题其实在于如果在inputStream.close的时候抛出异常，那么outStream.close()就不会执行，这很明显不是我们想要的结果，所以后面就改成了下面这种多重嵌套的方式去写：

    InputStream inputStream = new FileInputStream("file");
    try {
        System.out.println(inputStream.read(new byte[4]));
        try{
            OutputStream outStream = new FileOutputStream("file1");
            outStream.write(new byte[4]);
        }finally {
            outStream.close();
        }
    }finally {
        inputStream.close();
    }

在这种方式中即便是outStream.close()抛出了异常，但是我们依然会执行到inputStream.close(),因为他们是在不同的finally块，这个的确解决了我们的问题，但是还有两个问题没有解决：

• 带来的第一个问题就是如果我们有不止两个资源，比如有十个资源，难道需要让我们写十个嵌套的语句吗？写完之后这个代码还能看吗？
• 第二个问题就是如果我们在try里面出现异常，然后在finally里面又出现异常，就会导致异常覆盖，会导致finally里面的异常将try的异常覆盖了。

public class CloseTest {

    public void close(){
        throw new RuntimeException("close");
    }

    public static void main(String[] args) {
        CloseTest closeTest = new CloseTest();
        try{
            throw new RuntimeException("doSomething");
        }finally {
            closeTest.close();
        }
    }

}
输出结果：Exception in thread "main" java.lang.RuntimeException: close

上面这个代码，我们期望的是能抛出doSomething的这个异常，但是实际的数据结果却是close的异常，这和我们的预期不符合。

try-with-resources

上面我们介绍了两个问题，于是在java7中引入了try-with-resources的语句，只要我们的资源实现了AutoCloseable这个接口那么我们就可以使用这个语句了,我们之前的文件流已经实现了这个接口那么我们可以直接使用：

try(InputStream inputStream = new FileInputStream("file");
            OutputStream outStream = new FileOutputStream("file1")) {
            System.out.println(inputStream.read(new byte[4]));
            outStream.write(new byte[4]);
        }

我们所有的资源定义全部都在try后面的括号中进行定义，通过这种方式我们就可以解决上面所说的几个问题：

• 首先第一个问题，我们通过这样的方式，代码非常整洁，无论你有多少个资源，都可以很简洁的去做。
• 第二个异常覆盖问题的话，我们可以通过实验来看一下，我们将代码改写为如下：

public class CloseTest implements AutoCloseable {

    @Override
    public void close(){
        System.out.println("close");
        throw new RuntimeException("close");
    }

    public static void main(String[] args) {
        try(CloseTest closeTest = new CloseTest();
            CloseTest closeTest1 = new CloseTest();){
            throw new RuntimeException("Something");
        }
    }

}
输出结果为：
close
close
Exception in thread "main" java.lang.RuntimeException: Something
	at fudao.CloseTest.main(CloseTest.java:33)
	Suppressed: java.lang.RuntimeException: close
		at fudao.CloseTest.close(CloseTest.java:26)
		at fudao.CloseTest.main(CloseTest.java:34)
	Suppressed: java.lang.RuntimeException: close
		at fudao.CloseTest.close(CloseTest.java:26)
		at fudao.CloseTest.main(CloseTest.java:34)

我们在代码中定义了两个CloseTest，用来验证之前close出现异常是否会影响第二个，同时在close和try块里面都抛出不同的异常，可以看见我们的结果，输出了两个close,证明虽然close抛出异常，但是两个close都会执行。然后输出了doSomething的异常，可以发现这里我们输出的就是我们try块里面所抛出的异常，并且我们close的异常以Suppressed的方式记录在异常的堆栈里面，通过这样的方式我们两种异常都能记录下来。

try-with-resources原理

try-with-resources语句其实是一种语法糖，通过编译之后又回到了我们开始说的嵌套的那种模式：

可以发现try-with-resources被编译之后，又采取了嵌套的模式，但是和之前的嵌套有点不同，他close的时候都利用了catch去捕获了异常，然后添加到我们真正的异常中，整体逻辑比我们之前的嵌套要复杂一些。

总结

在我们关闭资源的时候，我们尽量优先推荐使用try-with-resources语句，但这里要注意的是很多资源其实是没有实现AutoCloseable接口的，比如我们最开始的Lock就没有实现这个接口，这个时候如果也想使用这种功能，可以采用组合的方式将Lock进行封装，来达到我们的目的。

如果大家觉得这篇文章对你有帮助，你的关注和转发是对我最大的支持，O(∩_∩)O: