是否有必要单独关闭每个嵌套的OutputStream和Writer？

时间：2015-02-02 11:10:36

标签： java file-io outputstream writer

我正在写一段代码：

OutputStream outputStream = new FileOutputStream(createdFile);
GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(gzipOutputStream));

我是否需要关闭以下每个流或作者？

gzipOutputStream.close();
bw.close();
outputStream.close();

或者只关闭最后一个流可以吗？

bw.close();

7 个答案:

答案 0 :(得分：142)

假设所有流都被创建好了，是的，只需关闭bw就可以了解这些流实现;但这是一个很大的假设。

我使用try-with-resources（tutorial），以便构建后续视频流的任何问题都不会使之前的视频流停止，因此您不会必须依赖具有调用关闭底层流的流实现：

try (
    OutputStream outputStream = new FileOutputStream(createdFile);
    GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
    OutputStreamWriter osw = new OutputStreamWriter(gzipOutputStream);
    BufferedWriter bw = new BufferedWriter(osw)
    ) {
    // ...
}

请注意，您根本不再致电close。

重要说明：要让资源试用关闭它们，必须在打开变量时将流分配给变量，不能使用嵌套。如果使用嵌套，则在构造其中一个后续流（例如，GZIPOutputStream）期间的异常将使嵌套调用构建的任何流都保持打开状态。来自JLS §14.20.3：

  

try-with-resources语句使用变量（称为资源）参数化，这些变量在执行try块之前初始化并自动关闭，顺序与它们相反在执行try块后初始化。

注意单词＆＃34;变量＆＃34; （我的重点）。

例如，不要这样做：

// DON'T DO THIS
try (BufferedWriter bw = new BufferedWriter(
        new OutputStreamWriter(
        new GZIPOutputStream(
        new FileOutputStream(createdFile))))) {
    // ...
}

...因为来自GZIPOutputStream(OutputStream)构造函数的异常（表示它可能抛出IOException，并将标头写入底层流）会使FileOutputStream保持打开状态。由于某些资源有可能抛出的构造函数而其他资源没有，所以将它们单独列出是一个好习惯。

我们可以用这个程序仔细检查我们对JLS部分的解释：

public class Example {

    private static class InnerMost implements AutoCloseable {
        public InnerMost() throws Exception {
            System.out.println("Constructing " + this.getClass().getName());
        }

        @Override
        public void close() throws Exception {
            System.out.println(this.getClass().getName() + " closed");
        }
    }

    private static class Middle implements AutoCloseable {
        private AutoCloseable c;

        public Middle(AutoCloseable c) {
            System.out.println("Constructing " + this.getClass().getName());
            this.c = c;
        }

        @Override
        public void close() throws Exception {
            System.out.println(this.getClass().getName() + " closed");
            c.close();
        }
    }

    private static class OuterMost implements AutoCloseable {
        private AutoCloseable c;

        public OuterMost(AutoCloseable c) throws Exception {
            System.out.println("Constructing " + this.getClass().getName());
            throw new Exception(this.getClass().getName() + " failed");
        }

        @Override
        public void close() throws Exception {
            System.out.println(this.getClass().getName() + " closed");
            c.close();
        }
    }

    public static final void main(String[] args) {
        // DON'T DO THIS
        try (OuterMost om = new OuterMost(
                new Middle(
                    new InnerMost()
                    )
                )
            ) {
            System.out.println("In try block");
        }
        catch (Exception e) {
            System.out.println("In catch block");
        }
        finally {
            System.out.println("In finally block");
        }
        System.out.println("At end of main");
    }
}

...有输出：

Constructing Example$InnerMost
Constructing Example$Middle
Constructing Example$OuterMost
In catch block
In finally block
At end of main

请注意，此处没有close的来电。

如果我们修复main：

public static final void main(String[] args) {
    try (
        InnerMost im = new InnerMost();
        Middle m = new Middle(im);
        OuterMost om = new OuterMost(m)
        ) {
        System.out.println("In try block");
    }
    catch (Exception e) {
        System.out.println("In catch block");
    }
    finally {
        System.out.println("In finally block");
    }
    System.out.println("At end of main");
}

然后我们会收到相应的close来电：

Constructing Example$InnerMost
Constructing Example$Middle
Constructing Example$OuterMost
Example$Middle closed
Example$InnerMost closed
Example$InnerMost closed
In catch block
In finally block
At end of main

（是的，对InnerMost#close的两次调用是正确的;一次来自Middle，另一次来自资源尝试。）

答案 1 :(得分：12)

您可以关闭最外层的流，实际上您不需要保留所有包裹的流，您可以使用Java 7 try-with-resources。

try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                     new GZIPOutputStream(new FileOutputStream(createdFile)))) {
     // write to the buffered writer
}

如果您订阅了YAGNI，或者您不需要它，那么您应该只添加实际需要的代码。您不应该添加您可能需要的代码，但实际上并没有做任何有用的事情。

以这个例子为例，想象如果你没有这样做会出现什么问题以及会产生什么影响呢？

try (
    OutputStream outputStream = new FileOutputStream(createdFile);
    GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
    OutputStreamWriter osw = new OutputStreamWriter(gzipOutputStream);
    BufferedWriter bw = new BufferedWriter(osw)
    ) {
    // ...
}

让我们从FileOutputStream开始，调用open来完成所有实际工作。

/**
 * Opens a file, with the specified name, for overwriting or appending.
 * @param name name of file to be opened
 * @param append whether the file is to be opened in append mode
 */
private native void open(String name, boolean append)
    throws FileNotFoundException;

如果找不到该文件，则没有要关闭的基础资源，因此关闭它不会产生任何影响。如果文件存在，则应抛出FileNotFoundException。因此，尝试仅从这一行关闭资源就没有任何好处。

您需要关闭文件的原因是文件成功打开，但后来出错。

让我们看一下下一个流GZIPOutputStream

有代码可以抛出异常

private void writeHeader() throws IOException {
    out.write(new byte[] {
                  (byte) GZIP_MAGIC,        // Magic number (short)
                  (byte)(GZIP_MAGIC >> 8),  // Magic number (short)
                  Deflater.DEFLATED,        // Compression method (CM)
                  0,                        // Flags (FLG)
                  0,                        // Modification time MTIME (int)
                  0,                        // Modification time MTIME (int)
                  0,                        // Modification time MTIME (int)
                  0,                        // Modification time MTIME (int)
                  0,                        // Extra flags (XFLG)
                  0                         // Operating system (OS)
              });
}

这会写入文件的标题。现在你能够打开一个文件进行写入但是甚至不能写入8个字节是非常不寻常的，但是让我们想象这可能发生，之后我们不会关闭文件。如果文件未关闭，会发生什么？

你没有得到任何未刷新的写入，它们被丢弃，在这种情况下，没有成功写入流的字节，无论如何都不会被缓冲。但是一个未关闭的文件并不会永远存在，而是FileOutputStream具有

protected void finalize() throws IOException {
    if (fd != null) {
        if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
            flush();
        } else {
            /* if fd is shared, the references in FileDescriptor
             * will ensure that finalizer is only called when
             * safe to do so. All references using the fd have
             * become unreachable. We can call close()
             */
            close();
        }
    }
}

如果你根本不关闭文件，它会被关闭，但不会立即关闭（就像我说的那样，留在缓冲区中的数据会以这种方式丢失，但此时没有）

不立即关闭文件的后果是什么？在正常情况下，您可能会丢失一些数据，并且可能会耗尽文件描述符。但是，如果你有一个系统，你可以创建文件，但你不能写任何东西，你有一个更大的问题。即使您失败了，也很难想象为什么你会反复尝试创建这个文件。

OutputStreamWriter和BufferedWriter都不会在其构造函数中抛出IOException，因此不清楚它们会导致什么问题。在BufferedWriter的情况下，您可能会得到一个OutOfMemoryError。在这种情况下，它会立即触发GC，正如我们所见，无论如何都会关闭文件。

答案 2 :(得分：6)

如果已经实例化了所有流，那么仅关闭最外层就好了。

关于Closeable接口的文档说明了关闭方法：

  

关闭此流并释放与其关联的所有系统资源。

释放系统资源包括关闭流。

它还声明：

  

如果流已经关闭，则调用此方法无效。

因此，如果你事后明确地关闭它们，那么不会发生任何错误。

答案 3 :(得分：6)

我宁愿使用try(...)语法（Java 7），例如

try (OutputStream outputStream = new FileOutputStream(createdFile)) {
      ...
}

答案 4 :(得分：5)

如果您只关闭最后一个流，那就没关系了 - 关闭呼叫也会发送到底层流。

答案 5 :(得分：5)

不，最高级别Stream或reader将确保关闭所有底层流/阅读器。

检查最高级别流的close()方法实现。

答案 6 :(得分：5)

在Java 7中，有一个功能try-with-resources。你不需要明确地关闭你的流，它会处理这个。

相关问题
最新问题