Comprima documentos de cualquier tamaño aplicando paralelismo

Descripción general

Paralelización de archivos BZIP2, LZIP y XZ

La paralelización está habilitada para ciertos formatos de archivo debido a su naturaleza inherente basada en bloques. Aspose.ZIP aprovecha esto empleando un enfoque de compresión multinúcleo común a nivel de programa. Los usuarios pueden controlar la cantidad de subprocesos utilizados para la compresión mediante el método setCompressionThreads(int) . Cuando este valor se establece en más de uno, se utilizarán varios núcleos de CPU para una compresión más rápida.

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

En el ejemplo 1 se muestra la creación de un archivo Bzip2 utilizando la clase Bzip2Archive. Primero, especificamos el archivo fuente que se comprimirá utilizando el método archive.setSource("data.bin"). A continuación, se pueden configurar varias opciones de compresión, incluida la cantidad de flujos de compresión, utilizando el objeto Bzip2SaveOptions. Finalmente, el archivo se guarda con las opciones especificadas utilizando el método archive.save("archive.bz2", opciones).
En el segundo ejemplo, configuramos los parámetros de compresión para el formato xz antes de crear el archivo. Esta configuración se realiza utilizando el objeto XzArchiveSettings, donde especificamos la cantidad deseada de flujos de compresión. Luego, se crea un nuevo XzArchive con esta configuración pasada como argumento. A continuación, el archivo fuente ("data.bin") se establece como fuente para la compresión y el archivo se guarda utilizando el método archive.save("archive.xz").
En el tercer ejemplo, demostramos la creación de un archivo LZ utilizando el objeto LzipArchiveSettings. Primero, configuramos el tamaño del diccionario utilizado por la compresión LZMA. A continuación, establecemos el número de subprocesos en 4. Después de eso, creamos un objeto LzipArchive y pasamos el objeto LzipArchiveSettings al constructor. Finalmente, especificamos el archivo a archivar y guardamos el archivo.

Compresión LZMA2 y subprocesos múltiples en archivos 7Z

Uno de los métodos de compresión dentro del formato 7z, LZMA2 , admite la compresión multiproceso. De manera similar a los formatos de archivo anteriores, puede controlar la cantidad de subprocesos utilizados con el método 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");
    }

• Configuración de compresión: Comenzamos creando configuraciones de compresión utilizando el objeto SevenZipLZMA2CompressionSettings. En este ejemplo, el número de flujos de compresión se establece en 4.
• Configuración de entrada: A continuación, se crea un objeto SevenZipEntrySettings y se le asignan las configuraciones de compresión que definimos anteriormente. Este paso configura la compresión para cada registro individual dentro del archivo.
• Creación del archivo: Con todas las configuraciones en su lugar, creamos un objeto SevenZipArchive y le pasamos la configuración de entrada. Este archivo contendrá una única entrada llamada "first.bin" que corresponde al archivo fuente "data.bin".
• Guardar el archivo: Finalmente, se guarda el archivo creado. como "resultado.7z" usando el método save("result.7z").

Acelere el archivado ZIP con compresión paralela

Se ha implementado la paralelización para un procesamiento más rápido a nivel de bloque o algoritmo para formatos de archivo anteriores en Aspose.ZIP. Sin embargo, los archivos ZIP ofrecen una ventaja única: paralelización básica durante el guardado. Para habilitar esto, cree una instancia de un objeto ParallelOptions al guardar el archivo 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);
    } 

Este código utiliza compresión paralela para optimizar la creación de archivos y crea un archivo ZIP llamado "archive.zip" a partir de todos los archivos dentro de la carpeta "C:\Data".