Comprima documentos de qualquer tamanho aplicando paralelismo

Visão geral

Paralelizando arquivos BZIP2, LZIP e XZ

A paralelização está habilitada para determinados formatos de arquivo devido à sua natureza inerente baseada em blocos. Aspose.ZIP aproveita isso empregando uma abordagem comum de compactação multi-core no nível do programa. Os usuários podem controlar o número de threads usados ​​para compactação por meio do método setCompressionThreads(int) . Quando esse valor for definido como maior que um, vários núcleos de CPU serão utilizados para compactação mais 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");
    }

No Exemplo 1 demonstra a criação de um arquivo Bzip2 usando a classe Bzip2Archive. Primeiro, especificamos o arquivo fonte a ser compactado usando o método archive.setSource("data.bin"). A seguir, várias opções de compactação, incluindo o número de fluxos de compactação, podem ser configuradas usando o objeto Bzip2SaveOptions. Finalmente, o arquivo é salvo com as opções especificadas usando o método archive.save("archive.bz2", options).
No segundo exemplo, configuramos os parâmetros de compressão para o formato xz antes de criar o arquivo. Esta configuração é feita através do objeto XzArchiveSettings, onde especificamos o número desejado de fluxos de compactação. Em seguida, um novo XzArchive é criado com essas configurações passadas como argumento. Em seguida, o arquivo fonte ("data.bin") é definido como fonte para compactação e o arquivo é salvo usando o método archive.save("archive.xz").
No terceiro exemplo, demonstramos a criação de um arquivo LZ usando o objeto LzipArchiveSettings. Primeiro, definimos o tamanho do dicionário usado pela compactação LZMA. A seguir, definimos o número de threads como 4. Depois disso, criamos um objeto LzipArchive e passamos o objeto LzipArchiveSettings para o construtor. Finalmente, especificamos o arquivo a ser arquivado e salvamos o arquivo.

Compressão LZMA2 e multithreading em arquivos 7Z

Um dos métodos de compactação no formato 7z, LZMA2 , oferece suporte à compactação multithread. Semelhante aos formatos de arquivo anteriores, você pode controlar o número de threads usados ​​com o 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");
    }

• Configurações de compactação: Começamos criando configurações de compactação usando o objeto SevenZipLZMA2CompressionSettings. Neste exemplo, o número de fluxos de compactação é definido como 4.
• Configurações de entrada: Em seguida, um objeto SevenZipEntrySettings é criado e recebe as configurações de compactação que definimos anteriormente. Esta etapa configura a compactação para cada registro individual dentro do arquivo.
• Criando o arquivo: Com todas as configurações definidas, criamos um objeto SevenZipArchive e passamos a ele as configurações de entrada. Este arquivo conterá uma única entrada chamada "first.bin" que corresponde ao arquivo de origem "data.bin".
• Salvando o arquivo: Finalmente, o arquivo criado é salvo como "result.7z" usando o método save("result.7z").

Acelere o arquivamento ZIP com compactação paralela

A paralelização para processamento mais rápido foi implementada em nível de bloco ou algoritmo para formatos de arquivo anteriores em Aspose.ZIP. No entanto, os arquivos ZIP oferecem uma vantagem única: paralelização básica durante o salvamento. Para habilitar isso, instancie um objeto ParallelOptions ao salvar o arquivo 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 compactação paralela para otimizar a criação de arquivos e cria um arquivo ZIP chamado “archive.zip” de todos os arquivos na pasta “C:\Data”.