Comment puis-je optimiser la vitesse d'écriture lors de l'écriture de données volumineuses dans des fichiers texte en Java ?

Étude de la vitesse optimale pour l'écriture de données massives dans des fichiers texte en Java

L'écriture de données volumineuses dans des fichiers texte peut être une tâche fastidieuse et atteindre la vitesse optimale est crucial. Cet article explore la technique la plus rapide pour écrire de grandes quantités de données en Java à l'aide du format de fichier texte.

Le goulot d'étranglement avec BufferedWriter

Lors de l'utilisation de BufferedWriter pour écrire des données dans un fichier texte, le tampon par défaut la taille peut entraîner un ralentissement des performances. En effet, BufferedWriter vide périodiquement le tampon interne dans le flux de fichiers sous-jacent, introduisant des surcharges supplémentaires.

Suppression de BufferedWriter

Pour optimiser la vitesse d'écriture, envisagez d'éliminer BufferedWriter et d'utiliser directement FileWriter. Cette approche élimine la surcharge de vidage de la mémoire tampon et permet au système d'effectuer des écritures directes dans la mémoire cache du disque.

Mesures des performances

Empiriquement, la suppression de BufferedWriter améliore considérablement la vitesse d'écriture. Un test réalisé avec 4 millions de chaînes (175 Mo) a montré une réduction du temps d'écriture de 40 secondes à environ 4-5 secondes sur un système moderne.

Isolation des frais généraux

Pour identifier les goulots d'étranglement dans le processus d’écriture, il est essentiel de séparer le temps passé à récupérer les enregistrements du temps consommé par l’écriture des fichiers. En effectuant des tests séparés pour chaque tâche, vous pouvez identifier les domaines dans lesquels des améliorations de performances peuvent être apportées.

Implémentation alternative

Le code Java suivant fournit une implémentation alternative utilisant à la fois l'écriture de fichiers directe et mise en mémoire tampon, permettant des comparaisons entre différentes tailles de tampon :

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

Cette implémentation révèle les avantages en termes de rapidité de l'utilisation de l'écriture directe de fichiers et fournit un aperçu de l'influence des différentes tailles de tampon sur l'écriture performances.

En optimisant le processus d'écriture de fichiers et en supprimant les surcharges inutiles, Java vous permet d'écrire efficacement des données volumineuses dans des fichiers texte. L'écriture directe de fichiers ou l'utilisation de BufferedWriter avec de grandes tailles de tampon peuvent améliorer considérablement la vitesse d'écriture, vous permettant de gérer même des ensembles de données volumineux avec une vitesse remarquable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!