Comprimeer documenten van elk formaat door parallellisme toe te passen

Overzicht

Parallellisatie van BZIP2-, LZIP- en XZ-archieven

Parallellisatie is mogelijk voor bepaalde archiefformaten vanwege hun inherente, op blokken gebaseerde karakter. Aspose.ZIP maakt hier gebruik van door gebruik te maken van een gemeenschappelijke multi-core compressiebenadering op programmaniveau. Gebruikers kunnen het aantal threads dat voor compressie wordt gebruikt, beheren via de methode setCompressionThreads(int) . Wanneer deze waarde wordt ingesteld op groter dan één, worden meerdere CPU-kernen gebruikt voor snellere compressie.

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

In voorbeeld 1 demonstreert u het maken van een Bzip2-archief met behulp van de klasse Bzip2Archive. Eerst specificeren we het bronbestand dat moet worden gecomprimeerd met behulp van de archive.setSource(“data.bin”) methode. Vervolgens kunnen verschillende compressieopties, waaronder het aantal compressiestreams, worden geconfigureerd met behulp van het Bzip2SaveOptions-object. Ten slotte wordt het archief opgeslagen met de opgegeven opties met behulp van de archive.save(“archive.bz2”, opties) methode.
In het tweede voorbeeld configureren we de compressieparameters voor het xz-formaat voordat we het archief maken. Deze configuratie wordt uitgevoerd met behulp van het XzArchiveSettings-object, waarbij we het gewenste aantal compressiestreams specificeren. Vervolgens wordt een nieuw XzArchive gemaakt waarbij deze instellingen als argument worden doorgegeven. Daarna wordt het bronbestand (“data.bin”) ingesteld als de bron voor compressie en wordt het archief opgeslagen met behulp van de archive.save(“archive.xz”) methode.
In het derde voorbeeld demonstreren we het maken van een LZ-archief met behulp van het LzipArchiveSettings-object. Eerst stellen we de grootte in van het woordenboek dat wordt gebruikt door LZMA-compressie. Vervolgens stellen we het aantal threads in op 4. Daarna maken we een LzipArchive-object en geven we het LzipArchiveSettings-object door aan de constructor. Ten slotte specificeren we het bestand dat moet worden gearchiveerd en slaan we het archief op.

LZMA2-compressie en multithreading in 7Z-archieven

Een van de compressiemethoden binnen het 7z-formaat, LZMA2 , ondersteunt multithreaded compressie. Net als bij eerdere archiefformaten kunt u het aantal gebruikte threads beheren met de methode 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");
    }

• Compressie-instellingen: We beginnen met het maken van compressie-instellingen met behulp van het SevenZipLZMA2CompressionSettings-object. In dit voorbeeld is het aantal compressiestreams ingesteld op 4.
• Invoerinstellingen: Vervolgens wordt een SevenZipEntrySettings-object gemaakt waaraan de compressie-instellingen worden toegewezen die we eerder hebben gedefinieerd. Met deze stap configureert u de compressie voor elk afzonderlijk record in het archief.
• Het archief maken: Als alle instellingen zijn ingevoerd, maken we een SevenZipArchive-object en geven hieraan de invoerinstellingen door. Dit archief bevat één item met de naam "first.bin" dat overeenkomt met het bronbestand "data.bin".
• Het archief opslaan: Ten slotte wordt het gemaakte archief opgeslagen als "result.7z" met behulp van de save("result.7z") methode.

Versnel ZIP-archivering met parallelle compressie

Parallellisatie voor snellere verwerking is geïmplementeerd op blok- of algoritmeniveau voor eerdere archiefformaten in Aspose.ZIP. ZIP-archieven bieden echter een uniek voordeel: parallellisatie op instapniveau tijdens het opslaan. Om dit in te schakelen, instantiëert u een object ParallelOptions bij het opslaan van het ZIP-archief.

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

Deze code maakt gebruik van parallelle compressie om het maken van archieven te optimaliseren en creëert een ZIP-archief met de naam “archive.zip” van alle bestanden in de map “C:\Data”.