W którym momencie jest pakowanie FileOutputStream z sensie BufferedOutputStream, pod względem wydajności?

Question

Mam moduł odpowiedzialny za odczytywanie, przetwarzanie i zapisywanie bajtów na dysku. Bajty przechodzą przez UDP i po złożeniu poszczególnych datagramów, ostateczna tablica bajtów, która jest przetwarzana i zapisywana na dysk, ma zwykle rozmiar od 200 bajtów do 500 000 bajtów. Zdarza się, że będą macierze bajtowe, które po złożeniu mają ponad 500 000 bajtów, ale są one stosunkowo rzadkie.

Obecnie używam FileOutputStream 's write(byte\[\]) method. Eksperymentuję również z zawijaniem FileOutputStream w BufferedOutputStream, w tym przy użyciu the constructor that accepts a buffer size as a parameter.

Wygląda na to, że używanie BufferedOutputStream prowadzi do nieco lepszej wydajności, ale dopiero zacząłem eksperymentować z różnymi rozmiarami buforów. Mam tylko ograniczony zestaw przykładowych danych do pracy (dwa zestawy danych z próbnych przebiegów, które mogę przepuścić przez moją aplikację). Czy istnieje ogólna zasada, którą mógłbym zastosować, aby spróbować obliczyć optymalne rozmiary buforów, aby zmniejszyć zapisy na dysku i zmaksymalizować wydajność zapisu na dysku, biorąc pod uwagę informacje, które znam o danych, które piszę?

Answer 1

BufferedOutputStream pomaga, gdy zapisy są mniejsze niż rozmiar bufora, np. 8 KB. W przypadku większych zapisów nie pomaga, ani nie czyni go znacznie gorszym. Jeśli WSZYSTKIE twoje zapisy są większe niż rozmiar bufora lub zawsze wypróżniasz() po każdym zapisie, nie używałbym bufora. Jednak jeśli znaczna część twoich zapisów jest mniejsza niż rozmiar bufora i nie używasz flush() za każdym razem, warto.

Może się okazać, że zwiększenie rozmiaru bufora do 32 KB lub większego spowoduje marginalną poprawę lub pogorszenie. YMMV

---

Można znaleźć kod BufferedOutputStream.write przydatnych

/** 
* Writes <code>len</code> bytes from the specified byte array 
* starting at offset <code>off</code> to this buffered output stream. 
* 
* <p> Ordinarily this method stores bytes from the given array into this 
* stream's buffer, flushing the buffer to the underlying output stream as 
* needed. If the requested length is at least as large as this stream's 
* buffer, however, then this method will flush the buffer and write the 
* bytes directly to the underlying output stream. Thus redundant 
* <code>BufferedOutputStream</code>s will not copy data unnecessarily. 
* 
* @param  b  the data. 
* @param  off the start offset in the data. 
* @param  len the number of bytes to write. 
* @exception IOException if an I/O error occurs. 
*/ 
public synchronized void write(byte b[], int off, int len) throws IOException { 
    if (len >= buf.length) { 
     /* If the request length exceeds the size of the output buffer, 
      flush the output buffer and then write the data directly. 
      In this way buffered streams will cascade harmlessly. */ 
     flushBuffer(); 
     out.write(b, off, len); 
     return; 
    } 
    if (len > buf.length - count) { 
     flushBuffer(); 
    } 
    System.arraycopy(b, off, buf, count, len); 
    count += len; 
} 

Answer 2

Mam ostatnio próbuje zbadać wydajność IO. Z tego co zauważyłem, bezpośrednie napisanie do FileOutputStream doprowadziło do lepszych wyników; które przypisałem natywnemu wywołaniu FileOutputStream dla write(byte[], int, int). Co więcej, zauważyłem również, że kiedy opóźnienie BufferedOutputStream zaczyna się zbiegać w kierunku opóźnienia w kierunku bezpośredniej wartości FileOutputStream, zmienia się ono o wiele więcej, to znaczy może gwałtownie nawet podwajać się (nie byłem jeszcze w stanie dowiedzieć się dlaczego).

P.S. Używam Java 8 i nie będę mógł teraz komentować, czy moje obserwacje będą się utrzymywać dla poprzednich wersji java.

Oto kod I przetestowane, gdzie mój wkład był plik ~ 10kB

public class WriteCombinationsOutputStreamComparison { 
    private static final Logger LOG = LogManager.getLogger(WriteCombinationsOutputStreamComparison.class); 

public static void main(String[] args) throws IOException { 

    final BufferedInputStream input = new BufferedInputStream(new FileInputStream("src/main/resources/inputStream1.txt"), 4*1024); 
    final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 
    int data = input.read(); 
    while (data != -1) { 
     byteArrayOutputStream.write(data); // everything comes in memory 
     data = input.read(); 
    } 
    final byte[] bytesRead = byteArrayOutputStream.toByteArray(); 
    input.close(); 

    /* 
    * 1. WRITE USING A STREAM DIRECTLY with entire byte array --> FileOutputStream directly uses a native call and writes 
    */ 
    try (OutputStream outputStream = new FileOutputStream("src/main/resources/outputStream1.txt")) { 
     final long begin = System.nanoTime(); 
     outputStream.write(bytesRead); 
     outputStream.flush(); 
     final long end = System.nanoTime(); 
     LOG.info("Total time taken for file write, writing entire array [nanos=" + (end - begin) + "], [bytesWritten=" + bytesRead.length + "]"); 
     if (LOG.isDebugEnabled()) { 
      LOG.debug("File reading result was: \n" + new String(bytesRead, Charset.forName("UTF-8"))); 
     } 
    } 

    /* 
    * 2. WRITE USING A BUFFERED STREAM, write entire array 
    */ 

    // changed the buffer size to different combinations --> write latency fluctuates a lot for same buffer size over multiple runs 
    try (BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream("src/main/resources/outputStream1.txt"), 16*1024)) { 
     final long begin = System.nanoTime(); 
     outputStream.write(bytesRead); 
     outputStream.flush(); 
     final long end = System.nanoTime(); 
     LOG.info("Total time taken for buffered file write, writing entire array [nanos=" + (end - begin) + "], [bytesWritten=" + bytesRead.length + "]"); 
     if (LOG.isDebugEnabled()) { 
      LOG.debug("File reading result was: \n" + new String(bytesRead, Charset.forName("UTF-8"))); 
     } 
    } 
} 
} 

WYJŚCIE:

2017-01-30 23:38:59.064 [INFO] [main] [WriteCombinationsOutputStream] - Total time taken for file write, writing entire array [nanos=100990], [bytesWritten=11059] 

2017-01-30 23:38:59.086 [INFO] [main] [WriteCombinationsOutputStream] - Total time taken for buffered file write, writing entire array [nanos=142454], [bytesWritten=11059]