Compressez des documents de toutes tailles en appliquant le parallélisme

Aperçu

Parallélisation des archives BZIP2, LZIP et XZ

La parallélisation est activée pour certains formats d’archives en raison de leur nature inhérente basée sur des blocs. Aspose.ZIP exploite cela en utilisant une approche de compression multicœur commune au niveau du programme. Les utilisateurs peuvent contrôler le nombre de threads utilisés pour la compression via la méthode setCompressionThreads(int) . Lorsque cette valeur est supérieure à un, plusieurs cœurs de processeur seront utilisés pour une compression plus rapide.

Parallel compression to BZIP2

    try (Bzip2Archive archive = new Bzip2Archive()) {
        archive.setSource("data.bin");
        Bzip2SaveOptions options = new Bzip2SaveOptions();
        options.setCompressionThreads(4);
        archive.save("archive.bz2", options);
    }

Parallel compression to XZ

    XzArchiveSettings settings = new XzArchiveSettings();
    settings.setCompressionThreads(4);
    try (XzArchive archive = new XzArchive(settings)) {
        archive.setSource("data.bin");
        archive.save("archive.xz");
    }

Parallel compression to LZ

    LzipArchiveSettings settings = new LzipArchiveSettings(16777216);
    settings.setCompressionThreads(4);
    try (LzipArchive archive = new LzipArchive(settings)) {
        archive.setSource("data.bin");
        archive.save("archive.lz");
    }

Dans l’exemple 1, il montre la création d’une archive Bzip2 à l’aide de la classe Bzip2Archive. Tout d’abord, nous spécifions le fichier source à compresser à l’aide de la méthode archive.setSource("data.bin"). Ensuite, diverses options de compression, notamment le nombre de flux de compression, peuvent être configurées à l’aide de l’objet Bzip2SaveOptions. Enfin, l’archive est enregistrée avec les options spécifiées à l’aide de la méthode archive.save("archive.bz2", options).
Dans le deuxième exemple, nous configurons les paramètres de compression pour le format xz avant de créer l’archive. Cette configuration se fait à l’aide de l’objet XzArchiveSettings, où l’on précise le nombre de flux de compression souhaité. Ensuite, un nouveau XzArchive est créé avec ces paramètres passés en argument. Ensuite, le fichier source ("data.bin") est défini comme source de compression et l’archive est enregistrée à l’aide de la méthode archive.save("archive.xz").
Dans le troisième exemple, nous démontrons la création d’une archive LZ à l’aide de l’objet LzipArchiveSettings. Tout d’abord, nous définissons la taille du dictionnaire utilisé par la compression LZMA. Ensuite, nous définissons le nombre de threads sur 4. Après cela, nous créons un objet LzipArchive et transmettons l’objet LzipArchiveSettings au constructeur. Enfin, nous spécifions le fichier à archiver et enregistrons l’archive.

Compression LZMA2 et multithreading dans les archives 7Z

L’une des méthodes de compression au format 7z, LZMA2 , prend en charge la compression multithread. Semblable aux formats d’archives précédents, vous pouvez contrôler le nombre de threads utilisés avec la méthode setCompressionThreads(int).

    SevenZipLZMA2CompressionSettings compSettings = new SevenZipLZMA2CompressionSettings();
    compSettings.setCompressionThreads(4);
    SevenZipEntrySettings settings = new SevenZipEntrySettings(compSettings);
    try (SevenZipArchive archive = new SevenZipArchive(settings)) {
        archive.createEntry("first.bin", "data.bin");
        archive.save("result.7z");
    }

• Paramètres de compression : Nous commençons par créer des paramètres de compression à l'aide de l'objet SevenZipLZMA2CompressionSettings. Dans cet exemple, le nombre de flux de compression est défini sur 4.
• Paramètres d'entrée : Ensuite, un objet SevenZipEntrySettings est créé et se voit attribuer les paramètres de compression que nous avons définis précédemment. Cette étape configure la compression pour chaque enregistrement individuel dans l'archive.
• Création de l'archive : Avec tous les paramètres en place, nous créons un objet SevenZipArchive et lui transmettons les paramètres d'entrée. Cette archive contiendra une seule entrée nommée "first.bin" qui correspond au fichier source "data.bin".
• Sauvegarde de l'archive : Enfin, l'archive créée est enregistrée comme "result.7z" en utilisant la méthode save("result.7z").

Accélérez l'archivage ZIP avec la compression parallèle

La parallélisation pour un traitement plus rapide a été implémentée au niveau du bloc ou de l’algorithme pour les formats d’archives précédents dans Aspose.ZIP. Cependant, les archives ZIP offrent un avantage unique : une parallélisation d’entrée de gamme lors de la sauvegarde. Pour activer cela, instanciez un objet ParallelOptions lors de l’enregistrement de l’archive ZIP.

    try (Archive archive = new Archive()) {
        archive.createEntries("C:\\Data");
        ParallelOptions parOptions = new ParallelOptions();
        parOptions.setParallelCompressInMemory(ParallelCompressionMode.Auto);
        ArchiveSaveOptions options = new ArchiveSaveOptions();
        options.setParallelOptions(parOptions);
        archive.save("archive.zip", options);
    } 

Ce code utilise la compression parallèle pour optimiser la création d’archives et crée une archive ZIP nommée « archive.zip » à partir de tous les fichiers du dossier « C:\Data ».