Comprimi documenti di qualsiasi dimensione applicando il parallelismo

Overview

Parallelizzazione degli archivi BZIP2, LZIP e XZ

La parallelizzazione è abilitata per alcuni formati di archivio a causa della loro natura intrinsecamente basata su blocchi. Aspose.ZIP sfrutta questo aspetto impiegando un approccio di compressione multi-core comune a livello di programma. Gli utenti possono controllare il numero di thread utilizzati per la compressione tramite il metodo setCompressionThreads(int) . Quando questo valore è impostato su un valore maggiore di uno, verranno utilizzati più core della CPU per una compressione più rapida.

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");
    }

Nell’esempio 1 viene illustrata la creazione di un archivio Bzip2 utilizzando la classe Bzip2Archive. Innanzitutto, specifichiamo il file sorgente da comprimere utilizzando il metodo archive.setSource("data.bin"). Successivamente, varie opzioni di compressione, incluso il numero di flussi di compressione, possono essere configurate utilizzando l’oggetto Bzip2SaveOptions. Infine, l’archivio viene salvato con le opzioni specificate utilizzando il metodo archive.save("archive.bz2", options).
Nel secondo esempio, configuriamo i parametri di compressione per il formato xz prima di creare l’archivio. Questa configurazione viene eseguita utilizzando l’oggetto XzArchiveSettings, dove specifichiamo il numero desiderato di flussi di compressione. Quindi, viene creato un nuovo XzArchive con queste impostazioni passate come argomento. Successivamente, il file sorgente ("data.bin") viene impostato come sorgente per la compressione e l’archivio viene salvato utilizzando il metodo archive.save("archive.xz").
Nel terzo esempio, dimostriamo la creazione di un archivio LZ utilizzando l’oggetto LzipArchiveSettings. Per prima cosa impostiamo la dimensione del dizionario utilizzato dalla compressione LZMA. Successivamente, impostiamo il numero di thread su 4. Successivamente, creiamo un oggetto LzipArchive e passiamo l’oggetto LzipArchiveSettings al costruttore. Infine, specifichiamo il file da archiviare e salviamo l’archivio.

Compressione LZMA2 e multithreading negli archivi 7Z

Uno dei metodi di compressione all’interno del formato 7z, LZMA2 , supporta la compressione multithread. Analogamente ai formati di archivio precedenti, è possibile controllare il numero di thread utilizzati con il metodo 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");
    }

• Impostazioni di compressione: Iniziamo creando le impostazioni di compressione utilizzando l'oggetto SevenZipLZMA2CompressionSettings. In questo esempio, il numero di flussi di compressione è impostato su 4.
• Impostazioni voce: Successivamente, viene creato un oggetto SevenZipEntrySettings a cui vengono assegnate le impostazioni di compressione definite in precedenza. Questo passaggio configura la compressione per ogni singolo record all'interno dell'archivio.
• Creazione l'archivio: con tutte le impostazioni a posto, creiamo un oggetto SevenZipArchive e gli passiamo le impostazioni della voce. Questo archivio conterrà una singola voce denominata "first.bin" "data.bin".
• Salvataggio dell'archivio: Infine, l'archivio creato viene salvato come "result.7z" ("result.7z").

Velocizza l'archiviazione ZIP con la compressione parallela

La parallelizzazione per un’elaborazione più rapida è stata implementata a livello di blocco o algoritmo per i formati di archivio precedenti in Aspose.ZIP. Tuttavia, gli archivi ZIP offrono un vantaggio unico: la parallelizzazione entry-level durante il salvataggio. Per abilitare ciò, creare un’istanza di un oggetto ParallelOptions quando si salva l’archivio 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);
    } 

Questo codice utilizza la compressione parallela per ottimizzare la creazione dell’archivio e crea un archivio ZIP denominato "archive.zip" da tutti i file all’interno della cartella "C:\Data".