web-dev-qa-db-ja.com

FileOutputStreamをBufferedOutputStreamでラップすると、パフォーマンスの点でどの時点で意味がありますか？

バイトの読み取り、処理、ディスクへの書き込みを担当するモジュールがあります。バイトはUDP経由で受信され、個々のデータグラムが組み立てられた後、処理されてディスクに書き込まれる最終的なバイト配列は、通常200バイトから500,000バイトの間です。たまに、アセンブリ後、500,000バイトを超えるバイト配列がありますが、これらは比較的まれです。

現在 FileOutputStream の write(byte\[\]) method を使用しています。 FileOutputStreamを BufferedOutputStream でラップする実験も行っています。これには、 パラメーターとしてバッファーサイズを受け入れるコンストラクター の使用も含まれます。

BufferedOutputStreamを使用すると、パフォーマンスがわずかに向上する傾向にありますが、私はさまざまなバッファサイズで実験を始めたばかりです。処理するサンプルデータのセットが限られています（アプリケーションをパイプ処理できるサンプル実行からの2つのデータセット）。書き込み中のデータについて知っている情報を考慮して、ディスク書き込みを減らし、ディスク書き込みのパフォーマンスを最大化するために最適なバッファーサイズを計算するために適用できる一般的な経験則はありますか？

javafile-ioiofileoutputstreambufferedoutputstream
44
Thomas Owens

BufferedOutputStreamは、書き込みがバッファサイズよりも小さい場合に役立ちます。 8 KB。大規模な書き込みの場合、それは役に立ちませんし、それをさらに悪化させることもありません。すべての書き込みがバッファーサイズよりも大きい場合、または書き込みのたびに常にflush（）を実行する場合は、バッファーを使用しません。ただし、書き込みのかなりの部分がバッファサイズより少なく、毎回flush（）を使用しない場合は、その価値があります。

バッファサイズを32 KB以上に増やすと、わずかに改善したり、悪化したりする場合があります。 YMMV

BufferedOutputStream.writeのコードが役立つかもしれません

/**
 * 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;
}
32
Peter Lawrey

私は最近IOパフォーマンスを探求しようとしています。私が観察したことから、FileOutputStreamに直接書き込むと、より良い結果が得られました。これはFileOutputStreamのwrite(byte[], int, int)へのネイティブコール。さらに、BufferedOutputStreamのレイテンシが直接FileOutputStreamのレイテンシに収束し始めると、さらに変動すること、つまり、突然、2倍になりました（まだ理由がわかりません）。

追伸私はJava 8を使用しており、現在の私の観察が以前のJavaバージョンに当てはまるかどうかについて現在コメントすることはできません。

私がテストしたコードは次のとおりです。ここで、入力は最大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")));
        }
    }
}
}

出力：

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]
1
Dev Amitabh