Quant a Multi-Threading i Processos múltiples a Node.js

Bloc

Quant a Multi-Threading i Processos múltiples a Node.js

Quant a Multi-Threading i Processos múltiples a Node.js

En aquest article, parlem de multithreading i multiprocés a Node.js i obtindrem una comprensió profunda de multiithreading i multiprocessos a Node.js. Hi ha un cert valor de referència, els amics que ho necessiten hi poden fer referència, espero ajudar a tothom.

NodeJS és un entorn d'execució de JavaScript multiplataforma d'ús gratuït que, tot i que té un únic fil, però utilitza diversos fils en segon pla per executar codi asíncron.

A causa del caràcter no bloquejador de Node.js, diferents fils executen devolucions de trucada diferents que primer es deleguen al bucle d'esdeveniments. El temps d'execució de NodeJS és responsable de gestionar tot això.

Per què NodeJS?

JS es va crear originalment com un llenguatge de programació de fil únic destinat a funcionar només dins d’un navegador web. El que això significa és que en un procés, només un conjunt d'instruccions va poder executar-se en un moment determinat.

L'execució es va passar al següent bloc de codi només quan el bloc de codi actual va acabar l'execució. Tanmateix, la naturalesa d'un únic fil de JS va facilitar la implementació.

En els seus humils inicis, JavaScript era útil per afegir només una petita interacció als llocs web. Per tant, no hi havia res que exigís el multithreading. No obstant això, els temps han canviat, els requisits dels usuaris s’han intensificat i JavaScript s’ha convertit en el popular llenguatge de programació de la web.

Ara el multithreading s’ha convertit en habitual. Com que JS és un llenguatge de fil únic, no és possible aconseguir-hi múltiples fils. Afortunadament, hi ha una gran solució disponible per a aquesta situació; NodeJS.

No hi ha escassetat per fer-ho Marcs NodeJS gràcies a la popularitat de l'entorn d'execució de JS, en particular i JavaScript, en general. Abans de continuar amb l'article, informeu-nos sobre alguns punts importants sobre Node.js:

  1. És possible passar missatges al procés bifurcat i al procés mestre des del procés bifurcat mitjançant la funció d'enviament
  2. Hi ha assistència per forcar diversos processos
  3. L'estat no es comparteix entre els processos mestre i els bifurcats

Per què forquear un procés?

Hi ha dos casos en què hem de forçar un procés:

  1. Per millorar la velocitat delegant tasques en algun altre procés
  2. Per alliberar memòria i descarregar un sol procés

És possible enviar dades al procés forcat i tornar-les a enviar.

El camí del nodeJS

Node.js fa servir dos tipus de fils:

  1. El fil principal gestionat pel bucle d'esdeveniments i,
  2. Molts fils auxiliars a la piscina de treballadors

El bucle d’esdeveniments és responsable de realitzar devolucions de trucada, o funcions, i registrar-les per a la seva execució en el futur. Funciona en el mateix fil que el del codi JS adequat. Un cop una operació JS bloqueja el fil, el bucle d'esdeveniments també es bloqueja.

El grup de treballadors és un model d’execució encarregat de generar i manipular diferents fils. Sincrònicament realitza la tasca i, a continuació, torna el resultat al bucle d'esdeveniments, que després executa la devolució de trucada proporcionada amb el resultat indicat.

En resum, l’agrupació de treballadors s’encarrega de les operacions d’E / S asíncrones, és a dir, de les interaccions realitzades amb el disc i la xarxa del sistema. Mòduls com el fs i el crypto són els que utilitzen principalment l'agrupació de treballadors.

http fxnetworks com activa xboxone

A mesura que el grup de treballadors s'implementa a biblioteca libuv , hi ha un petit retard quan Node.js requereix comunicar-se internament entre JS i C ++. No obstant això, això és gairebé imperceptible.

Tot és bo fins que trobem el requisit d'executar d'una operació complexa de manera síncrona. Qualsevol funció que requereixi molt de temps per executar-se provocarà el bloqueig del fil principal.

Si l’aplicació té diverses funcions que requereixen molta CPU, donarà lloc a una caiguda significativa del rendiment del servidor. En el pitjor dels casos, el servidor es congelarà i no hi haurà manera de delegar la feina al grup de treballadors.

Àrees com IA, big data i aprenentatge automàtic no es podrien beneficiar de NodeJS a causa de les operacions que bloquegen l’únic fil principal i que el servidor no respon. Tot i això, això va canviar amb l'arribada del NodeJS v10.5.0 que va afegir compatibilitat amb el multi-threading.

El repte de la simultaneïtat i tasques vinculades a la CPU

Establir simultaneïtat a JavaScript pot ser difícil. Permetre que diversos fils accedeixin als mateixos resultats de memòria en condicions de carrera que no només són difícils de reproduir, sinó que també són difícils de resoldre.

NodeJS es va implementar originalment com una plataforma del servidor basada en E / S asíncrones. Això va facilitar moltes coses simplement eliminant la necessitat de fils. Sí, les aplicacions Node.js tenen un únic fil, però no de la manera típica.

Podem executar les coses en paral·lel a Node.js. Tot i això, no hem de crear fils. El sistema operatiu i la màquina virtual executen col·lectivament les E / S en paral·lel i el codi JS s'executa en un únic fil quan arriba el moment d'enviar les dades al codi JavaScript.

Excepte el codi JS, tot funciona en paral·lel a Node.js. A diferència dels blocs asíncrons, els blocs síncrons de JS sempre s’executen d’un en un. En comparació amb l'execució de codi, es passa molt més temps a l'espera que es produeixin esdeveniments d'E / S a JS.

Una aplicació NodeJS simplement invoca les funcions o devolucions de trucada necessàries i no bloqueja l'execució d'un altre codi. Originalment, ni JavaScript ni NodeJS tenien la intenció de gestionar tasques que requereixen intensitat de CPU o vinculades a la CPU.

Quan el codi sigui mínim, l'execució serà àgil. Tanmateix, com més pesen els càlculs, més lenta s’executa.

Si encara heu intentat dur a terme tasques que requereixen una gran intensitat de CPU a JS i Node, es produirà la congelació de la IU al navegador i la posada en cua de qualsevol esdeveniment d'E / S, respectivament. Tot i això, hem recorregut un llarg camí. Ara tenim el mòdul worker_threads per estalviar el dia.

Multithreading simplificat amb el mòdul worker_threads

Publicat el juny de 2018, Node.js v10.5.0 va introduir el mòdul worker_threads. Facilita la implementació de simultaneïtat al popular entorn d'execució de JavaScript. El mòdul permet crear aplicacions NodeJS multithreaded completament funcionals.

Tècnicament, un fil de treball és un codi que es genera en un fil separat. Per començar a utilitzar fils de treball, primer cal que importeu el mòdul de treballadors. Després, cal crear una instància de la classe Worker per crear un fil de treballador.

Quan es crea una instància de la classe Worker, hi ha dos arguments:

  1. El primer proporciona un camí d'accés al fitxer, amb extensions .js o .mjs, que conté el codi del fil del treballador i,
  2. El segon proporciona un objecte que conté una propietat workerData que conté les dades que el subprocés del treballador pot accedir quan comença l'execució.

Els fils de treball són capaços d'enviar més d'un esdeveniment de missatge. Com a tal, es dóna preferència a l'enfocament de devolució de trucada sobre l'opció de retornar una promesa.

La comunicació entre els fils del treballador es basa en esdeveniments, és a dir, es configuren els oients tan aviat com el fil del treballador enviï l’esdeveniment. 4 dels esdeveniments més habituals són:

worker.on('error', (error) => {});
  1. S'emet quan hi ha una excepció no capturada dins del fil del treballador. A continuació, el fil del treballador finalitza i l'error es posa a disposició com a primer argument de la devolució de trucada proporcionada.
worker.on('exit', (exitCode) => {})

2. S'emet quan surt un fil de treballador. exitCode es proporcionaria a la devolució de trucada si process.exit () es cridava dins del fil de treball. El codi és 1 si worker.terminate () finalitza el fil del treballador.

worker.on('message', (data) => {});

3. S'emet quan un fil de treballador envia dades al fil principal.

worker.on('online', () => {});

4. S'emet quan un fil de treballador deixa d'analitzar el codi JS i comença l'execució. Tot i que no s’utilitza habitualment, l’esdeveniment en línia pot ser informatiu en escenaris específics.

Maneres d'utilitzar els fils Worker

Hi ha dues maneres d'utilitzar fils de treball:

  • Enfocament 1 - Implica la generació d'un fil de treballador, l'execució del seu codi i l'enviament del resultat al fil principal. Aquest enfocament necessita crear un treballador nou des de zero cada vegada que faci una nova tasca.
  • Enfocament 2 - Implica la generació d’un fil de treballador i la configuració d’oients per a l’esdeveniment del missatge. Cada vegada que s'activa el missatge, el fil treballador executa el codi i torna el resultat al fil principal. El fil del treballador continua viu per al seu ús futur.

L’aproximació 2 també es coneix com agrupació de treballadors. Això es deu al fet que l'enfocament implica crear un grup de treballadors, posar-los a l'espera i enviar l'esdeveniment del missatge per fer la tasca quan sigui necessari.

Com que crear un fil de treball des de zero requereix crear una màquina virtual i analitzar i executar codi, el documentació oficial de NodeJS recomana emprar l'enfocament 2. A més, l'enfocament 2 és més eficient que l'enfocament 1.

Propietats importants disponibles al mòdul worker_threads

  • isMainThread - Aquesta propietat és certa quan no funciona dins d'un fil de treballador. Si cal, es pot incloure una declaració simple if al començament del fitxer del treballador. Això garanteix que només s'executi com a fil de treball.
  • parentPort - Una instància de MessagePort, s'utilitza per comunicar-se amb el fil principal.
  • threadId - Un identificador únic assignat al fil del treballador.
  • Dades del treballador - Conté les dades incloses al constructor del fil del treballador pel fil de generació.

Multiprocessament en NodeJS

Per tal d’aprofitar la potència d’un sistema multi-nucli mitjançant Node.js, hi ha processos disponibles. El popular entorn d’execució de JS presenta un mòdul anomenat clúster que proporciona suport per al processament múltiple.

El mòdul de clúster permet generar diversos processos fills, que poden compartir un port comú. Un sistema que utilitza NodeJS pot gestionar més càrregues de treball quan els processos secundaris es posen en acció.

Node.js per al backend

Internet ja s’ha convertit en la plataforma escollida per milions, si no milers de milions, a tot el món. Per tant, per impulsar una empresa al màxim potencial i deixar sense resoldre la seva causa, és obligatori tenir una presència en línia sòlida.

Tot comença amb un lloc web potent i intuïtiu. Per fer un lloc web impecable, és important triar les millors tecnologies de frontend i backend. Tot i que té un caràcter únic, Node.js és la millor opció en la causa de serveis de desenvolupament web de backend .

Tot i tenir una gran quantitat d’opcions de backend amb múltiples fils, a les empreses de renom els agrada optar per NodeJS. Això es deu al fet que Node.js ofereix la solució per utilitzar multithreading a JavaScript, que ja és el llenguatge de programació més popular de la web.

Conclusió

El mòdul worker_threads ofereix una manera senzilla d'implementar multithreading a les aplicacions Node.js. El rendiment d’un servidor es pot millorar significativament delegant càlculs pesats de CPU als fils de treball.

Amb el nou suport del multithreading, NodeJS continuarà arribant a més i més desenvolupadors, enginyers i altres professionals de camps amb un càlcul intens, com ara IA, big data i aprenentatge automàtic.

#nodejs #javascript # multi-threading # multiple-process