Jak tworzyć wątki w nodejs

Czy istnieje sposób tworzenia wątków do uruchamiania wielu metod jednocześnie?

W ten sposób, jeśli jakakolwiek metoda zawiedzie pomiędzy wszystkimi innymi wątkami, powinna zostać zabita.

Każdy proces node.js jest oparty na jednym wątku zgodnie z projektem. Dlatego, aby uzyskać wiele wątków, musisz mieć wiele procesów (jak zauważyli niektórzy inni plakaty, istnieją również biblioteki, do których możesz się podłączyć, które dadzą ci możliwość pracy z wątkami w Node, ale nie ma takiej możliwości bez tych bibliotek . Zobacz odpowiedź Shawna Vincenta, odnoszącą się do https://github.com/audreyt/node-webworker-threads )

Procesy potomne można uruchamiać z procesu głównego, jak pokazano tutaj w dokumentacji node.js: http://nodejs.org/api/child_process.html . Przykłady na tej stronie są całkiem dobre i są dość proste.

Twój proces nadrzędny może wtedy obserwować zdarzenie zamknięcia dowolnego procesu, który rozpoczął, a następnie wymusić zamknięcie innych procesów, które rozpocząłeś, aby osiągnąć rodzaj strategii jednego niepowodzenia wszystkich zatrzymań, o których mówisz.

Zobacz także: Node.js na maszynach wielordzeniowych

Istnieje również co najmniej jedna biblioteka do wykonywania natywnych wątków z poziomu Node.js: node-webworker-thread

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

Zasadniczo implementuje to interfejs API przeglądarki Web Worker dla node.js.

Od Node 10.5 dostępna jest teraz obsługa wielu wątków , ale jest to eksperymentalne . Mam nadzieję, że wkrótce się to ustabilizuje.

Do kasy następujące zasoby:

• Wątek PR .
• Oficjalna dokumentacja
• Artykuł na blogu: Wątki w Node 10.5.0: praktyczne wprowadzenie

Aktualizacja :

Począwszy od wersji 11.7.0 Node nie musisz używać --experimental-workerflagi.

Uwaga do wydania: https://nodejs.org/en/blog/release/v11.7.0/

Możesz uzyskać wielowątkowość za pomocą Napa.js.

https://github.com/Microsoft/napajs

„Napa.js to wielowątkowe środowisko wykonawcze JavaScript zbudowane na V8, które zostało pierwotnie zaprojektowane do tworzenia wysoce iteracyjnych usług o niezakłóconej wydajności w Bing. W miarę jego rozwoju uważamy, że przydatne jest uzupełnianie Node.js w zadaniach związanych z procesorem , z możliwością wykonywania JavaScript w wielu izolatach V8 i komunikowania się między nimi. Napa.js jest udostępniany jako moduł Node.js, ale może być również osadzony w procesie hosta bez zależności Node.js. ”

Jeśli używasz Rx, raczej łatwo jest podłączyć klaster rxjs, aby podzielić pracę na wykonywanie równoległe. (zastrzeżenie: jestem autorem)

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

Potrzebowałem prawdziwej wielowątkowości w Node.js i tym, co zadziałało, był pakiet wątków . Tworzy inny proces mający własną pętlę komunikatów Node.js, więc nie blokują się nawzajem. Konfiguracja jest łatwa, a dokumentacja umożliwia szybkie rozpoczęcie pracy. Twój główny program i pracownicy mogą komunikować się na dwa sposoby, a „wątki” pracowników mogą zostać zabite w razie potrzeby.

Ponieważ wielowątkowość i Node.js są skomplikowanym i szeroko dyskutowanym tematem, dość trudno było znaleźć pakiet, który działałby na moje specyficzne wymagania. Dla przypomnienia te nie działały dla mnie :

• tiny-worker pozwolił na spawnowanie pracowników, ale wydawało się, że mają tę samą pętlę wiadomości (ale być może zrobiłem coś źle - wątki miały więcej dokumentacji, co daje mi pewność naprawdę używało wielu procesów, więc kontynuowałem, dopóki nie zadziałało)
• webworker-wątki nie pozwalająrequire modułów w których potrzebowałem

A dla tych, którzy pytają, dlaczego potrzebowałem prawdziwej wielowątkowości: dla aplikacji obejmującej Raspberry Pi i przerwań. Jeden wątek obsługuje te przerwania, a inny zajmuje się przechowywaniem danych (i nie tylko).

Nodejs 10.5.0 uwolnienie ogłosił wielowątkowość w node.js . Ta funkcja jest nadal eksperymentalna. Jest nowy plik work_threads moduł .

Możesz rozpocząć korzystanie z wątków roboczych, jeśli używasz Node.js w wersji 10.5.0 lub nowszej , ale jest to eksperymentalny interfejs API . Nie jest dostępny domyślnie: musisz go włączyć za pomocą  --experimental-worker podczas wywoływania Node.js.

Oto przykład z włączonymi ES6 i worker_threads , przetestowany w wersji 12.3.1

//package.json

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

Teraz musisz zaimportować Workera z pliku worker_threads . Uwaga: Aby obsługiwać ES6, musisz zadeklarować pliki js z rozszerzeniem „.mjs” .

//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();

Na koniec tworzymy plik 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}`);

Wynik:

npm run start

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

Jest teraz również https://github.com/xk/node-threads-a-gogo , chociaż nie jestem pewien co do statusu projektu.

NodeJS zawiera teraz wątki (jako funkcja eksperymentalna w momencie odpowiadania).

Może szukasz Promise.race (natywnego rozwiązania wyścigowego we / wy, a nie wątków)

Zakładając, że ty (lub inne osoby szukające tego pytania) chcesz ścigać wątki, aby uniknąć awarii i kosztów operacji we / wy, jest to prosty i natywny sposób na osiągnięcie tego (który nie wykorzystuje wątków). Węzeł został zaprojektowany jako jednowątkowy (sprawdź pętlę zdarzeń), więc jeśli to możliwe, unikaj używania wątków. Jeśli moje założenie jest prawidłowe, polecam skorzystać Promise.racez setTimeout(przykład w linku). Z tą strategią możesz wygrać listę obietnic, z których każda próbuje wykonać jakąś operację we / wy i odrzucać obietnicę, jeśli wystąpi błąd (w przeciwnym razie przekroczenie limitu czasu). Promise.raceOświadczenie kontynuuje po pierwszym rozdzielczości / odrzucenia, który wydaje się być to, co chcesz. Mam nadzieję, że to komuś pomoże!

Node.js nie używa wątków. Według jego wynalazcy to kluczowa cecha. W momencie jego wynalezienia wątki były powolne, problematyczne i trudne. Node.js powstał w wyniku badania wydajnej alternatywy jednordzeniowej. Większość entuzjastów Node.js wciąż cytuje stare argumenty, jakby wątki nie były ulepszane przez ostatnie 50 lat.

Jak wiesz, Node.js służy do uruchamiania JavaScript. Język JavaScript również rozwijał się przez lata. Teraz ma sposoby korzystania z wielu rdzeni - czyli to, co robią wątki. Tak więc, dzięki postępom w JavaScript, możesz wykonywać wielozadaniowość w swoich aplikacjach. user158 wskazuje, że Node.js trochę się nim bawi. Nic o tym nie wiem. Ale po co czekać, aż Node.js zatwierdzi to, co ma do zaoferowania JavaScript.

Google dla wielowątkowości JavaScript zamiast wielowątkowości Node.js. Dowiesz się o pracownikach sieci Web, obietnicach i innych rzeczach.