Come creare thread in nodejs

Esiste un modo per creare thread per eseguire più metodi alla volta?

In questo modo, se un metodo fallisce tra tutti gli altri thread, dovrebbe essere ucciso.

Ogni processo node.js è a thread singolo per progettazione. Pertanto per ottenere più thread, devi avere più processi (come alcuni altri poster hanno sottolineato, ci sono anche librerie a cui puoi collegarti che ti daranno la possibilità di lavorare con i thread in Node, ma tale capacità non esiste senza quelle librerie . Vedi la risposta di Shawn Vincent che fa riferimento a https://github.com/audreyt/node-webworker-threads )

Puoi avviare i processi figli dal tuo processo principale come mostrato qui nella documentazione di node.js: http://nodejs.org/api/child_process.html . Gli esempi sono abbastanza buoni in questa pagina e sono piuttosto semplici.

Il tuo processo genitore può quindi guardare l'evento di chiusura su qualsiasi processo avviato e quindi potrebbe forzare la chiusura degli altri processi che hai avviato per ottenere il tipo di strategia di arresto di tutti i tipi di cui stai parlando.

Vedi anche: Node.js su macchine multi-core

Esiste anche almeno una libreria per eseguire il threading nativo dall'interno di Node.js: node-webworker-threads

https://github.com/audreyt/node-webworker-threads

Questo fondamentalmente implementa l' API del browser Web Worker per node.js.

Dal nodo 10.5 è ora disponibile il supporto multi threading , ma è sperimentale . Spero che questo diventi presto stabile.

Controlla le seguenti risorse:

• Discussione PR .
• Documentazione ufficiale
• Articolo del blog: Thread nel nodo 10.5.0: un'introduzione pratica

Aggiornamento :

Dal nodo v11.7.0 in poi, non è necessario utilizzare --experimental-workerflag.

Nota di rilascio: https://nodejs.org/en/blog/release/v11.7.0/

Puoi ottenere il multi-threading usando Napa.js.

https://github.com/Microsoft/napajs

"Napa.js è un runtime JavaScript multi-thread basato su V8, originariamente progettato per sviluppare servizi altamente iterativi con prestazioni non compromesse in Bing. Man mano che si evolve, troviamo utile integrare Node.js nelle attività legate alla CPU , con la capacità di eseguire JavaScript in più isolati V8 e di comunicare tra loro. Napa.js è esposto come un modulo Node.js, mentre può anche essere incorporato in un processo host senza dipendenza da Node.js. "

Se stai usando Rx, è piuttosto semplice plug-in in rxjs-cluster per dividere il lavoro in esecuzione parallela. (disclaimer: sono l'autore)

https://www.npmjs.com/package/rxjs-cluster

Avevo bisogno di un vero multithreading in Node.js e quello che ha funzionato per me è stato il pacchetto di thread . Genera un altro processo con il proprio loop di messaggi Node.js, quindi non si bloccano a vicenda. La configurazione è semplice e la documentazione ti consente di essere subito operativo. Il programma principale e i worker possono comunicare in entrambi i modi e, se necessario, i "thread" worker possono essere interrotti.

Poiché il multithreading e Node.js è un argomento complicato e ampiamente discusso, è stato abbastanza difficile trovare un pacchetto che funzioni per le mie esigenze specifiche. Per la cronaca questi non hanno funzionato per me :

• tiny-worker consentiva la generazione dei lavoratori, ma sembravano condividere lo stesso ciclo di messaggi (ma potrebbe essere che ho fatto qualcosa di sbagliato - i thread avevano più documentazione dandomi la sicurezza che utilizzava davvero più processi, quindi ho continuato finché non ha funzionato)
• webworker-thread non consentiva requiremoduli nei worker di cui avevo bisogno

E per coloro che chiedono perché avevo bisogno di un vero multi-threading: per un'applicazione che coinvolge il Raspberry Pi e interrompe. Un thread gestisce tali interruzioni e un altro si occupa di memorizzare i dati (e altro).

Il nodejs 10.5.0 rilascio ha annunciato multithreading in Node.js . La funzione è ancora sperimentale. È ora disponibile un nuovo modulo worker_threads .

Puoi iniziare a utilizzare i thread di lavoro se esegui Node.js v10.5.0 o versioni successive , ma questa è un'API sperimentale . Non è disponibile per impostazione predefinita: è necessario abilitarlo utilizzando  --experimental-worker quando si richiama Node.js.

Ecco un esempio con ES6 e worker_threads abilitati, testato sulla versione 12.3.1

//package.json

  "scripts": {
  "start": "node  --experimental-modules --experimental- worker index.mjs"
  },

Ora, devi importare Worker da worker_threads . Nota: è necessario dichiarare i file js con estensione ".mjs" per il supporto ES6.

//index.mjs
import { Worker } from 'worker_threads';

const spawnWorker = workerData => {
    return new Promise((resolve, reject) => {
        const worker = new Worker('./workerService.mjs', { workerData });
        worker.on('message', resolve);
        worker.on('error', reject);
        worker.on('exit', code => code !== 0 && reject(new Error(`Worker stopped with 
        exit code ${code}`)));
    })
}

const spawnWorkers = () => {
    for (let t = 1; t <= 5; t++)
        spawnWorker('Hello').then(data => console.log(data));
}

spawnWorkers();

Infine, creiamo un workerService.mjs

//workerService.mjs
import { workerData, parentPort, threadId } from 'worker_threads';

// You can do any cpu intensive tasks here, in a synchronous way
// without blocking the "main thread"
parentPort.postMessage(`${workerData} from worker ${threadId}`);

Produzione:

npm run start

Hello from worker 4
Hello from worker 3
Hello from worker 1
Hello from worker 2
Hello from worker 5

Ora c'è anche https://github.com/xk/node-threads-a-gogo , anche se non sono sicuro dello stato del progetto.

NodeJS ora include i thread (come funzionalità sperimentale al momento della risposta).

Potresti cercare Promise.race(soluzione di corse I / O nativa, non thread)

Supponendo che tu (o altri che stanno cercando questa domanda) vogliate affrontare i thread per evitare errori ed evitare il costo delle operazioni di I / O, questo è un modo semplice e nativo per farlo (che non utilizza i thread). Il nodo è progettato per essere a thread singolo (cerca il loop degli eventi), quindi evita di usare i thread se possibile. Se la mia ipotesi è corretta, ti consiglio di utilizzare Promise.racecon setTimeout(esempio nel link). Con questa strategia, si correrà un elenco di promesse in cui ciascuna tenta di eseguire alcune operazioni di I / O e si rifiuta la promessa in caso di errore (altrimenti timeout). La Promise.racedichiarazione continua dopo la prima risoluzione / rifiuto, che sembra essere quello che vuoi. Spero che questo aiuti qualcuno!

Node.js non utilizza il threading. Secondo il suo inventore, questa è una caratteristica fondamentale. Al momento della sua invenzione, i thread erano lenti, problematici e difficili. Node.js è stato creato come risultato di un'indagine su un'alternativa single-core efficiente. La maggior parte degli appassionati di Node.js cita ancora i tuoi vecchi argomenti come se i thread non fossero stati migliorati negli ultimi 50 anni.

Come sai, Node.js viene utilizzato per eseguire JavaScript. Anche il linguaggio JavaScript si è sviluppato negli anni. Ora ha modi per utilizzare più core, ovvero cosa fanno i thread. Quindi, tramite i progressi in JavaScript, puoi eseguire alcune operazioni multi-core multi-tasking nelle tue applicazioni. user158 sottolinea che Node.js ci sta giocando un po '. Non ne so niente. Ma perché aspettare che Node.js approvi ciò che JavaScript ha da offrire.

Multi-threading di Google per JavaScript invece del multi-threading di Node.js. Scoprirai i web worker, le promesse e altre cose.