Yuvalanmış her bir OutputStream ve Writer'ı ayrı ayrı kapatmak gerekli mi?

Bir kod yazıyorum:

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

Her yayını veya yazarı aşağıdaki gibi kapatmam gerekir mi?

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

Yoksa son akışı kapatmak iyi olur mu?

bw.close();

Tüm akışların bwsorunsuz bir şekilde oluşturulduğunu varsayarsak, evet, bu akış uygulamalarıyla kapatmak yeterlidir ; ama bu büyük bir varsayım.

Bana kalırsa doğru denemek-ile-kaynaklar ( öğretici size yakın çağrı sahip akışı uygulamasına güvenmek zorunda kalmamak için daha sonraki akışları inşa herhangi bir sorun istisnalar atar önceki akışları asılı terk etmediklerini böylece) ve temeldeki akış:

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

Artık aramadığınızı unutmayın close.

Önemli not : Kaynaklarla denemeyi kapatmak için, akışları açarken değişkenlere atamanız gerekir , iç içe geçmeyi kullanamazsınız. GZIPOutputStreamİç içe yerleştirmeyi kullanırsanız , sonraki akışlardan birinin oluşturulması sırasında bir istisna (örneğin ), içindeki yuvalanmış çağrılar tarafından oluşturulan herhangi bir akışı açık bırakır. Gönderen §14.20.3 JLS :

Kaynaklarla dene ifadesi, bloğun yürütülmesinden önce başlatılan ve bloğun yürütülmesinden sonra başlatıldıkları ters sırada otomatik olarak kapatılan değişkenlerle (kaynaklar olarak bilinir) parametrelendirilir .trytry

"Değişkenler" kelimesine dikkat edin (vurgu) .

Örneğin, bunu yapmayın:

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

... çünkü GZIPOutputStream(OutputStream)yapıcıdan gelen bir istisna (atabileceğini IOExceptionve temeldeki akışa bir başlık yazdığını söyler ) FileOutputStreamaçık bırakacaktır . Bazı kaynakların kuruculara sahip olması ve bazılarının atmaması nedeniyle, bunları ayrı ayrı listelemek iyi bir alışkanlıktır.

Bu JLS bölümüne ilişkin yorumumuzu bu programla iki kez kontrol edebiliriz:

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

... çıktısı olan:

Örnek Oluşturuluyor $ InnerMost
Örnek Oluşturuluyor $ Middle
Örnek Oluşturma $ OuterMost
Yakalama bloğunda
Sonunda blokta
Ana yolun sonunda

Orada arama closeolmadığını unutmayın.

Düzeltirsek 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");
}

sonra uygun closearamaları alıyoruz :

Örnek Oluşturuluyor $ InnerMost
Örnek Oluşturuluyor $ Middle
Örnek Oluşturma $ OuterMost
Örnek $ Orta kapalı
Örnek $ InnerMost kapalı
Örnek $ InnerMost kapalı
Yakalama bloğunda
Sonunda blokta
Ana yolun sonunda

(Evet, iki çağrı InnerMost#closedoğrudur; biri Middlekaynakla denemeden, diğeri kaynaklardan.)

En dıştaki akışı kapatabilirsiniz, aslında sarılmış tüm akışları tutmanıza gerek yoktur ve Java 7 kaynakla deneme özelliğini kullanabilirsiniz.

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

YAGNI'ye abone olursanız veya buna ihtiyacınız olmayacaksa, yalnızca gerçekten ihtiyacınız olan kodu eklemelisiniz. İhtiyaç duyabileceğinizi düşündüğünüz kodu eklememelisiniz, ancak gerçekte yararlı hiçbir şey yapmaz.

Bu örneği alın ve bunu yapmazsanız neyin yanlış gidebileceğini ve bunun etkisinin ne olacağını hayal edin.

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

openTüm gerçek işi yapmaya çağıran FileOutputStream ile başlayalım .

/**
 * 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;

Dosya bulunmazsa kapatılacak temel kaynak yoktur, bu nedenle kapatmak herhangi bir fark yaratmaz. Dosya varsa, bir FileNotFoundException oluşturması gerekir. Yani kaynağı tek başına bu hattan kapatmaya çalışmakla kazanılacak bir şey yok.

Dosyayı kapatmanızın nedeni, dosyanın başarıyla açıldığı, ancak daha sonra bir hata alacağınız zamandır.

Bir sonraki akışa bakalım GZIPOutputStream

Bir istisna atabilecek bir kod var

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

Bu, dosyanın başlığını yazar. Şimdi, bir dosyayı yazmak için açabilmeniz ancak ona 8 bayt bile yazamamanız çok alışılmadık bir durum olurdu, ancak bunun olabileceğini düşünelim ve sonra dosyayı kapatmayalım. Kapatılmamış bir dosyaya ne olur?

Herhangi bir boşaltılmamış yazma almazsınız, bunlar atılır ve bu durumda, bu noktada zaten arabelleğe alınmayan akışa başarıyla yazılmış baytlar yoktur. Ancak kapatılmamış bir dosya sonsuza kadar yaşamaz, bunun yerine FileOutputStream'de

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();
        }
    }
}

Bir dosyayı hiç kapatmazsanız, yine de kapatılır, hemen değil (ve dediğim gibi, bir arabellekte kalan veriler bu şekilde kaybolur, ancak bu noktada hiçbiri yoktur)

Dosyayı hemen kapatmamanın sonucu nedir? Normal koşullar altında, potansiyel olarak bazı verileri kaybedersiniz ve potansiyel olarak dosya tanımlayıcılarınız tükenir. Ancak dosya oluşturabileceğiniz bir sisteminiz varsa ancak bunlara hiçbir şey yazamıyorsanız, daha büyük bir sorununuz var. yani, başarısız olmanıza rağmen neden bu dosyayı tekrar tekrar oluşturmaya çalıştığınızı hayal etmek zor.

Hem OutputStreamWriter hem de BufferedWriter, kurucularında IOException oluşturmaz, bu nedenle hangi soruna neden olacakları net değildir. BufferedWriter durumunda, bir OutOfMemoryError alabilirsiniz. Bu durumda, derhal bir GC'yi tetikleyecektir, bu da gördüğümüz gibi dosyayı yine de kapatacaktır.

Tüm akışlar somutlaştırılmışsa, yalnızca en dıştaki akışı kapatmak yeterlidir.

CloseableArayüzle ilgili dokümantasyon, kapatma yöntemini belirtir:

Bu akışı kapatır ve onunla ilişkili tüm sistem kaynaklarını serbest bırakır.

Serbest bırakma sistemi kaynakları, kapanış akışlarını içerir.

Ayrıca şunu belirtir:

Akış zaten kapalıysa, bu yöntemi çağırmanın bir etkisi yoktur.

Yani daha sonra onları açıkça kapatırsanız, yanlış bir şey olmayacaktır.

try(...)Sözdizimini (Java 7) kullanmayı tercih ederim , örneğin

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

Yalnızca son akışı kapatırsanız sorun olmayacaktır - kapanış çağrısı da temeldeki akışlara gönderilecektir.

Hayır, en üst düzey Streamveya readertüm temel akışların / okuyucuların kapatılmasını sağlayacaktır .

En üst düzey akışınızın close()yöntem uygulamasını kontrol edin .

Java 7'de, kaynaklarla deneme özelliği vardır . Akışlarınızı açıkça kapatmanıza gerek yok, bununla ilgilenecektir.