Multi-threading para zip en nodejs

¿La operación de descompresión y descompresión se puede hacer multiproceso en nodejs?

Hay un montón de módulos como yauzl, pero ninguno usa varios subprocesos, y no puede iniciar varios subprocesos usted mismo con el nodo-cluster o algo así, porque cada archivo zip debe manejarse en un solo subproceso

Según la documentación de Zlib

Uso de Threadpool: todas las API de zlib, excepto aquellas que son explícitamente sincrónicas, usan el threadpool de libuv. Esto puede conducir a efectos sorprendentes en algunas aplicaciones, como un rendimiento inferior (que puede mitigarse ajustando el tamaño del grupo) y / o una fragmentación de memoria irrecuperable y catastrófica. https://nodejs.org/api/zlib.html#zlib_threadpool_usage

Según el conjunto de subprocesos de libuv, puede cambiar la variable de entorno UV_THREADPOOL_SIZEpara cambiar el tamaño máximo

Si, en cambio, desea comprimir muchos archivos pequeños al mismo tiempo, puede usar Worker Threads https://nodejs.org/api/worker_threads.html

Al leer su pregunta nuevamente, parece que quiere varios archivos. Use Worker Threads, estos no bloquearán su hilo principal y puede obtener la salida de ellos a través de promesas.

El nodo JS utiliza Libuv y el subproceso de trabajo. El subproceso de trabajo es una forma de realizar operaciones de manera multiproceso. Si usa libuv (mantiene el subproceso en el grupo de subprocesos), puede aumentar el subproceso del servidor nodo js predeterminado. Puede usar ambos para mejorar el rendimiento del nodo js para su operación.

Así que aquí hay documentación oficial para el hilo de trabajo: https://nodejs.org/api/worker_threads.html

Vea cómo puede aumentar el grupo de subprocesos en el nodo js aquí: imprima el tamaño del conjunto de subprocesos de libuv en el nodo js 8

Ayuda sobre cómo hacer subprocesos múltiples en el nodo js. Tendrás que crear debajo de tres archivos

index.mjs

import run from './Worker.mjs';

/**
* design your input list of zip files here and send them to `run` one file name at a time
* to zip, using a loop or something. It acts as promise.
* exmaple : run( <your_input> ).then( <your_output> );
**/

Worker.mjs

import { Worker } from 'worker_threads';

function runService(id, options) {
    return new Promise((resolve, reject) => {
        const worker = new Worker('./src/WorkerService.mjs', { workerData: { <your_input> } });
        worker.on('message', res => resolve({ res: res, threadId: worker.threadId }));
        worker.on('error', reject);
        worker.on('exit', code => {
            if (code !== 0)
                reject(new Error(`Worker stopped with exit code ${code}`));
        });
    });
}

async function run(id, options) {
    return await runService(id, options);
}

export default run;

WorkerService.mjs

import { workerData } from 'worker_threads';

// Here goes your logic for zipping a file, where as `workerData` will have <your_input>.

Avísame si te ayuda.

¿Se puede hacer que la operación de compresión y descompresión sea multiproceso en nodejs?

Si.

... y no puede iniciar varios subprocesos usted mismo ... porque cada archivo zip debe manejarse en un solo subproceso

Sospecho que su premisa es defectuosa. ¿Por qué cree exactamente que un proceso de nodo no puede iniciar varios subprocesos? Aquí hay una aplicación que estoy ejecutando que utiliza el módulo de clúster node.js muy maduro con un proceso principal que actúa como supervisor y dos procesos secundarios que realizan tareas vinculadas de E / S de red y disco.

Como puede ver en la Ccolumna, cada proceso se ejecuta en un hilo separado. Esto permite que el proceso maestro siga respondiendo a las tareas de comando y control (como generar / cosechar trabajadores) mientras los procesos de trabajo están vinculados a la CPU o al disco. Este servidor particular acepta archivos de la red, a veces los descomprime y los alimenta a través de procesadores de archivos externos. IOW, es una tarea que incluye compresión como la que usted describe.

No estoy seguro de que quieras usar hilos de trabajo basados ​​en este fragmento de los documentos :

Los trabajadores (hilos) son útiles para realizar operaciones JavaScript intensivas en CPU. No ayudarán mucho con el trabajo intensivo de E / S. Las operaciones de E / S asincrónicas integradas de Node.js son más eficientes que los trabajadores.

Para mí, esa descripción grita, "¡crypo!" En el pasado, he generado procesos secundarios al tener que realizar operaciones costosas de criptomonedas.

En otro proyecto, uso el módulo child_process del nodo y pongo en marcha un nuevo proceso hijo cada vez que tengo que comprimir un lote de archivos. Ese servicio en particular ve una lista de ~ 400 archivos con nombres similares process-me-2019.11.DD.MMy los concatena en un solo process-me-2019-11-DDarchivo. Se tarda un poco en comprimir, por lo que generar un nuevo proceso evita el bloqueo en el hilo principal.

No hay forma de que pueda realizar subprocesos múltiples en Nodejs puros hasta que use una biblioteca de terceros. Puede ejecutar el proceso en paralelo usando promesas. Si no desea sobrecargar el hilo principal que utiliza el nodo, puede implementar RabitMQ (Redis Queue). Se ejecutará en su propio hilo, por lo que su hilo principal nunca será bloqueado.