Ano ang pagkakaiba sa pagitan ng Node.js arkitekturang hinihimok ng kaganapan at programming na may maraming sinulid sa iba pang mga wika?


sagot 1:

Parehong nasa event-driven at ang multi-threaded paradigm ang code ay tumatakbo sa loob ng isang proseso ng operating system.

Kapag nagpapatakbo ang proseso ng maraming mga thread, ang mga thread na ito ay nagbabahagi ng memorya ng proseso (puwang ng address) kapwa para sa pagbabasa at pagsulat.

Ang JavaScript na nagpapatakbo ng Node.js ay single-threaded sa pamamagitan ng disenyo. Ang bawat pag-andar ay ginagarantiyahan na tatakbo hanggang sa pagkumpleto, at walang ibang code ng JavaScript sa kasalukuyang proseso ang tatakbo habang tumatakbo ang function na iyon. Ang likas na hindi nakakasabay na mga kaganapan (network, disk input-output, timers, iba pang mga kaganapan sa hardware at operating system) ay hinahawakan ng engine na nagdaragdag ng mga pag-andar ng JavaScript na nakarehistro bilang mga handler (o callback) para sa mga kaganapang ito sa pila ng mga kaganapan sa loop ng kaganapan upang maisagawa pagkatapos natapos ang mga pag-andar sa harap ng pila.

Sa paradigma ng multi-may sinulid, dalawa o higit pang mga thread ang nagpapatakbo ng code, kaya sa panahon ng isang function ay nagpapatakbo ng ibang piraso ng code ay maaaring tumakbo rin sa isang iba't ibang mga core ng processor, marahil ang pagbabasa o pagsulat sa parehong mga address ng memorya. Ito ay maaaring magresulta sa isang hindi pantay na estado ng memorya maliban kung ang mga espesyal na mekanismo ng operating system (pag-synchronise primitives) ay ginagamit ng code upang pamahalaan ang pag-access sa ibinahaging memorya.



sagot 2:

Ito ay isang magandang katanungan, "Ano ang pagkakaiba sa pagitan ng Node.js 'na hinihimok ng kaganapan na hinihimok ng arkitektura at multi-sinulid na programming sa iba pang mga wika?".

Maaari namin at dapat na masira ito nang kaunti.

  • Arkitektura na hinihimok ng kaganapan.

Ang arkitekturang hinimok sa kaganapan ay hindi eksklusibo sa Node, hal., Tornado (Python), Vertx (Java), Akka (Scala), ReactiveX (maraming mga wika).

  • Multiplayer na programa sa iba pang mga wika.

Tandaan na ang JavaScript, sa pamamagitan ng disenyo, ay hindi sumusuporta sa maraming mga thread. Kahit na sinusuportahan nito ang mga webmaster, na, sa pagkakaalam ko, ay maaaring gumana bilang mga thread.

Kaya ang kaganapan na hinihimok ay hindi natatangi sa Node at maaaring gawin ang multi-threading sa Node.

Kaya maaaring mayroong dalawang mga katanungan dito: "Ano ang pagkakaiba sa pagitan ng mga hinihimok ng kaganapan kumpara sa multi-threading", at "Ano ang pagkakaiba sa pagitan ng Node at iba pang mga wika (frameworks)". Itutuon ko ang huli mula nang tila iyon ang hangarin ng tanong.

Sasabihin ko kung ano ang gumagawa ng espesyal na Node ay nilikha ito ng may-akda para sa layuning maiwasan ang pag-block sa IO kapag nagtatayo ng mga web application. Ang kultura ng pamayanan ng Node ay upang bigyang-diin at mabuo sa lakas ng non-blocking IO. Hindi ka makakahanap ng masyadong maraming mga aklatan ng 3rd party na nagsasagawa ng pag-block ng mga tawag. Bilang isang developer gamit ang Node, malamang na hindi ka tumatakbo sa banayad na mga operasyon sa pag-block sa iyong code. Samantalang sa iba pang mga wika, ang isang walang katuturang developer ay maaaring hindi sinasadyang gumanap ng lubos na hindi mahusay na pag-block ng mga tawag tulad ng pagbabasa mula sa isang koneksyon sa database.

Maliban dito, dapat mong basahin ang tungkol sa maraming mga modelo para sa "kasabay" at maunawaan ang mga kalamangan at kahinaan ng bawat isa. Mga puntos ng bonus para sa pagpapahalaga kung bakit ang pagtanggap ng multi-threading sa loob ng mahabang panahon.



sagot 3:

ang mga pagkakaiba sa konsepto ay medyo madaling balutin ang iyong ulo.

Sa arkitektura na hinihimok ng kaganapan, ang iyong programa ay nagpapatakbo sa isang patuloy na solong may sinulid na loop (magagawa mo ang maraming mga sinulid na node ngunit huwag kang mag-alala tungkol sa ngayon). Kapag pumutok ang isang kaganapan, ang isang trabaho ay nasa call stack na haharapin sa mga programa sa paglilibang.

Ang arkitektura ng multi-thread na sa pangkalahatan ay nagpapadala ng isang bagong thread kapag dapat itong maghintay ng isang aksyon. Kaya, gumawa ka ng isang tawag sa isang database at magsulid ka ng isang bagong thread na isasagawa ang lahat ng mga bagay na kailangan mo at gawin ang kailangan mo at tapusin o muling pagsamahin ang orihinal na thread.

Ang parehong mga pamamaraan na ito ay napaka-kapaki-pakinabang para sa iba't ibang mga bagay. Ang hinimok sa kaganapan ay mahusay para sa interface ng gumagamit at mga server dahil ang iyong programa ay hindi alam kung kailan bago ang mangyayari at madalas na mga kaganapan ay darating sa mga pagsabog. Habang ang pag-thread ay kinakailangan para sa computationally mabibigat na trabaho kung saan nais mong masira ang isang problema sa mas maliit na mga piraso (o papalapit ka sa limitasyon ng iyong solong may sinulid na loop).