web-dev-qa-db-fra.com

Comment créer des threads dans nodejs

Est-il possible de créer des threads pour exécuter plusieurs méthodes à la fois. Si une méthode échoue entre tous les autres threads doit être tué.
Merci d'avance

multithreadingnode.jsasynchronousparallel-processing
76
user87267867

Chaque processus node.js est mono-threadé par conception. Par conséquent, pour obtenir plusieurs threads, vous devez avoir plusieurs processus (comme l'ont souligné d'autres afficheurs, il existe également des bibliothèques sur lesquelles vous pouvez créer un lien qui vous donneront la possibilité de travailler avec des threads dans Node, mais cette capacité n'existe pas sans ces bibliothèques. Voir la réponse de Shawn Vincent référençant https://github.com/audreyt/node-webworker-threads ) 

Vous pouvez démarrer des processus enfants à partir de votre processus principal, comme indiqué ici dans la documentation de node.js: http://nodejs.org/api/child_process.html . Les exemples sont très bons sur cette page et sont assez simples.

Votre processus parent peut alors surveiller l’événement de fermeture de n’importe quel processus qu’il a démarré, puis forcer la fermeture des autres processus que vous avez commencés pour obtenir le type de stratégie à échec unique dont vous parlez.

Voir aussi: Node.js sur des machines multi-core

85
Brian

Il existe également au moins une bibliothèque pour effectuer des threads natifs à partir de Node.js: node-webworker-threads

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

Cela implémente essentiellement le API du navigateur Web Worker pour node.js.

32
Shawn Vincent

À partir du nœud 10.5, il existe désormais un support multi-threading , mais c'est experimental. J'espère que cela va devenir stable bientôt. 

Commander les ressources suivantes:

11
user158

Vous pouvez avoir le multi-threading en utilisant Napa.js. 

https://github.com/Microsoft/napajs

"Napa.js est un moteur d'exécution JavaScript multi-thread construit sur la version 8, conçu à l'origine pour développer des services hautement itératifs avec des performances non compromises dans Bing. À mesure qu'il évolue, nous trouvons utile de compléter Node.js dans les tâches liées au processeur. , capable d'exécuter JavaScript dans plusieurs isolements V8 et de communiquer entre eux. Napa.js est exposé en tant que module Node.js, mais il peut également être intégré à un processus hôte sans dépendance Node.js. "

7
shmuli

Si vous utilisez Rx, il est assez simple de brancher rxjs-cluster pour scinder le travail en exécution parallèle. (disclaimer: je suis l'auteur)

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

4
Jonathan Dunlap

Il y a aussi maintenant https://github.com/xk/node-threads-a-gogo , mais je ne suis pas sûr du statut du projet.

2
shaunc

NodeJS inclut maintenant threads (en tant que fonctionnalité expérimentale au moment de répondre).

2
James Holmes

Vous êtes peut-être à la recherche de Promise.race (solution de course native d'E/S, pas de threads)

En supposant que vous (ou d’autres recherches sur cette question) veulez concurrencer les threads pour éviter les erreurs et éviter le coût des opérations d’entrée/sortie, il s’agit d’un moyen simple et natif de le réaliser (qui n’utilise pas de threads). Le nœud est conçu pour être à thread unique (recherchez la boucle d'événement), évitez donc d'utiliser des threads si possible. Si mon hypothèse est correcte, je vous recommande d'utiliser Promise.race avec setTimeout (exemple dans le lien). Avec cette stratégie, vous courriez une liste de promesses, chacune essayant une opération d’entrée/sortie et la rejetant en cas d’erreur (sinon timeout). L'instruction Promise.race continue après la première résolution/rejet, ce qui semble être ce que vous voulez. J'espère que cela aide quelqu'un!

1
smileham

La version de nodejs 10.5.0 a annoncé le multithreading dans Node.js . La fonctionnalité est encore expérimentale. Un nouveau module worker_threads est disponible.

Vous pouvez commencer à utiliser des threads de travail si vous exécutez Node.js version 10.5.0 ou supérieure , mais il s'agit d'une API expérimentale . Il n'est pas disponible par défaut: vous devez l'activer en utilisant - experimental-worker lors de l'appel de Node.js.

Voici un exemple avec ES6 et worker_threads activé, testé sur la version 12.3.1 

//package.json

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

Maintenant, vous devez importer Worker depuis worker_threads . Remarque: vous devez vous déclarer aux fichiers js dotés de l'extension '. Mjs pour la prise en charge de l'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();

Enfin, nous créons 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}`);

Sortie:

npm run start

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

Node.js n'utilise pas de thread. Selon son inventeur, c'est une caractéristique essentielle. Au moment de son invention, les fils étaient lents, problématiques et difficiles. Node.js a été créé à la suite d'une enquête sur une alternative efficace monocœur. La plupart des enthousiastes de Node.js citent encore votre vieil argument comme si les discussions n’avaient pas été améliorées au cours des 50 dernières années.

Comme vous le savez, Node.js est utilisé pour exécuter JavaScript. Le langage JavaScript s'est également développé au fil des ans. Il est maintenant possible d’utiliser plusieurs cœurs, c’est-à-dire ce que font les threads. Ainsi, grâce aux avancées de JavaScript, vous pouvez effectuer plusieurs tâches multitâches dans vos applications. user158 souligne que Node.js joue un peu avec. Je ne sais rien à ce sujet. Mais pourquoi attendre que Node.js approuve ce que JavaScript a à offrir. 

Google pour le multi-threading JavaScript au lieu du multi-thread Node.js. Vous en saurez plus sur les travailleurs Web, les promesses et d'autres choses.

0
Roger F. Gay