Нужно ли закрывать каждый вложенный 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();

Если предположить, что все потоки созданы нормально, да, просто закрытие bwподходит для этих реализаций потоков ; но это большое предположение.

Я бы использовал try-with-resources ( учебник ), чтобы любые проблемы, связанные с построением последующих потоков, которые генерируют исключения, не оставляют предыдущие потоки зависшими, и поэтому вам не нужно полагаться на реализацию потока, имеющую вызов close основной поток:

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блока.

Обратите внимание на слово «переменные» (выделено мной) .

Например, не делайте этого:

// 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");
    }
}

... который имеет вывод:

Пример создания $ InnerMost
Пример построения $ Middle
Пример создания $ OuterMost
В блоке захвата
В конечном блоке
В конце основного

Обратите внимание, что звонков туда 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вызовы:

Пример создания $ InnerMost
Пример построения $ Middle
Пример создания $ OuterMost
Пример $ Средний закрыт
Пример $ InnerСамый закрытый
Пример $ InnerСамый закрытый
В блоке захвата
В конечном блоке
В конце основного

(Да, два вызова InnerMost#close- это правильно; один - от Middle, другой - от try-with-resources.)

Вы можете закрыть самый внешний поток, на самом деле вам не нужно сохранять все потоки в оболочке, и вы можете использовать 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. В этом случае он немедленно запустит сборщик мусора, который, как мы видели, в любом случае закроет файл.

Если все потоки были созданы, то закрытие только самого внешнего вполне нормально.

В документации по Closeableинтерфейсу указан метод закрытия:

Закрывает этот поток и освобождает все связанные с ним системные ресурсы.

Высвобождающие системные ресурсы включают закрывающие потоки.

В нем также говорится, что:

Если поток уже закрыт, вызов этого метода не имеет никакого эффекта.

Поэтому, если вы потом явно закроете их, ничего плохого не произойдет.

Я бы предпочел использовать try(...)синтаксис (Java 7), например

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

Будет хорошо, если вы закроете только последний поток - вызов закрытия также будет отправлен в базовые потоки.

Нет, самый верхний уровень Streamили readerгарантирует, что все базовые потоки / читатели будут закрыты.

Проверьте реализациюclose() метода вашего потока самого верхнего уровня.

В Java 7 есть возможность попробовать с ресурсами . Вам не нужно явно закрывать свои потоки, он позаботится об этом.