Wie kann ich die Schreibgeschwindigkeit beim Schreiben großer Datenmengen in Textdateien in Java optimieren?

Untersuchung der optimalen Geschwindigkeit zum Schreiben großer Datenmengen in Textdateien in Java

Das Schreiben umfangreicher Daten in Textdateien kann eine zeitaufwändige Aufgabe sein und das Erreichen der optimalen Geschwindigkeit ist entscheidend. In diesem Artikel wird die schnellste Technik zum Schreiben großer Datenmengen in Java mithilfe des Textdateiformats untersucht.

Der Engpass bei BufferedWriter

Bei Verwendung von BufferedWriter zum Schreiben von Daten in eine Textdatei ist der Standardpuffer Größe kann zu einer langsameren Leistung führen. Dies liegt daran, dass BufferedWriter den internen Puffer regelmäßig in den zugrunde liegenden Dateistream leert, was zusätzlichen Overhead verursacht.

BufferedWriter entfernen

Um die Schreibgeschwindigkeit zu optimieren, sollten Sie erwägen, BufferedWriter zu eliminieren und den FileWriter direkt zu verwenden. Dieser Ansatz eliminiert den Puffer-Flushing-Overhead und ermöglicht es dem System, direkte Schreibvorgänge in den Cache-Speicher der Festplatte durchzuführen.

Leistungsmessungen

Empirisch verbessert das Entfernen von BufferedWriter die Schreibgeschwindigkeit erheblich. Ein mit 4 Millionen Zeichenfolgen (175 MB) durchgeführter Test zeigte eine Reduzierung der Schreibzeit von 40 Sekunden auf etwa 4–5 Sekunden auf einem modernen System.

Overhead isolieren

Um die Engpässe im zu identifizieren Während des Schreibprozesses ist es wichtig, die Zeit, die für das Abrufen von Datensätzen aufgewendet wird, von der Zeit zu trennen, die für das Schreiben von Dateien aufgewendet wird. Durch die Durchführung separater Tests für jede Aufgabe können Sie die Bereiche ermitteln, in denen Leistungsverbesserungen vorgenommen werden können.

Alternative Implementierung

Der folgende Java-Code bietet eine alternative Implementierung, die sowohl direktes als auch gepuffertes Dateischreiben verwendet. Ermöglicht Vergleiche zwischen verschiedenen Puffergrößen:

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.List;

public class FileWritingPerfTest {

    private static final int ITERATIONS = 5;
    private static final double MEG = (Math.pow(1024, 2));
    private static final int RECORD_COUNT = 4000000;
    private static final String RECORD = "Help I am trapped in a fortune cookie factory\n";
    private static final int RECSIZE = RECORD.getBytes().length;

    public static void main(String[] args) throws Exception {
        List<String> records = new ArrayList<String>(RECORD_COUNT);
        int size = 0;
        for (int i = 0; i < RECORD_COUNT; i++) {
            records.add(RECORD);
            size += RECSIZE;
        }
        System.out.println(records.size() + " 'records'");
        System.out.println(size / MEG + " MB");

        for (int i = 0; i < ITERATIONS; i++) {
            System.out.println("\nIteration " + i);

            writeRaw(records);
            writeBuffered(records, 8192);
            writeBuffered(records, (int) MEG);
            writeBuffered(records, 4 * (int) MEG);
        }
    }

    private static void writeRaw(List<String> records) throws IOException {
        File file = File.createTempFile("foo", ".txt");
        try {
            FileWriter writer = new FileWriter(file);
            System.out.print("Writing raw... ");
            write(records, writer);
        } finally {
            // comment this out if you want to inspect the files afterward
            file.delete();
        }
    }

    private static void writeBuffered(List<String> records, int bufSize) throws IOException {
        File file = File.createTempFile("foo", ".txt");
        try {
            FileWriter writer = new FileWriter(file);
            BufferedWriter bufferedWriter = new BufferedWriter(writer, bufSize);

            System.out.print("Writing buffered (buffer size: " + bufSize + ")... ");
            write(records, bufferedWriter);
        } finally {
            // comment this out if you want to inspect the files afterward
            file.delete();
        }
    }

    private static void write(List<String> records, Writer writer) throws IOException {
        long start = System.currentTimeMillis();
        for (String record: records) {
            writer.write(record);
        }
        // writer.flush(); // close() sh

Diese Implementierung zeigt die Geschwindigkeitsvorteile der Verwendung des direkten Schreibens von Dateien und bietet Einblicke in den Einfluss unterschiedlicher Puffergrößen auf das Schreiben Leistung.

Durch die Optimierung des Dateischreibprozesses und die Beseitigung unnötiger Overheads ermöglicht Ihnen Java das effiziente Schreiben umfangreicher Daten in Textdateien. Das direkte Schreiben von Dateien oder die Verwendung von BufferedWriter mit großen Puffergrößen kann die Schreibgeschwindigkeit erheblich steigern, sodass Sie selbst große Datenmengen mit bemerkenswerter Geschwindigkeit verarbeiten können.

Das obige ist der detaillierte Inhalt vonWie kann ich die Schreibgeschwindigkeit beim Schreiben großer Datenmengen in Textdateien in Java optimieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!