Utasítások
Párhuzamos számítással számold meg a betűk gyakoriságát szövegekben.
A párhuzamosság lényege, hogy olyan dolgokat végzünk párhuzamosan, amelyeket sorosan is el lehet végezni.
Gyakori példa erre a betűk gyakoriságának megszámolása.
Használj párhuzamosságot, hogy kiszámítsd az egyes betűk összesített gyakoriságát a szövegek listájában.
A JavaScript természeténél fogva egyszálas, ezért hiányoznak belőle azok a nyelvi eszközök, amelyekkel más nyelvek a párhuzamos kódfuttatást kezelik.
Valójában az egyetlen módja a „valódi” párhuzamos kódfuttatásnak a Worker threads (más néven Web Workers).
Szinte mindig az a kód, ami párhuzamosan futni látszik,
például az async functions vagy a Promises, valójában konkurensen hajtódik végre.
Ez gyakran jobb is, mert a modern JavaScript erre van optimalizálva,
és gyakran látsz majd olyan kódot, amely a Promise.all() és más konkurens végrehajtási módszerek használatával „utánozza” (vagy „csalja el”) a párhuzamos végrehajtást.
To pass the tests for this exercise, your solution needs to execute _concurrently_ (or in parallel),
meaning that synchronous solutions (e.g. a simple `for` loop) will not pass.
Konkurencia és párhuzamosság
Íme egy gyors definíció mindkettőre, amely szemlélteti a kettő közötti különbségeket:
- Konkurencia az, amikor két vagy több feladat egymást átfedő időszakokban indulhat, futhat és fejeződhet be, ugyanaz a feldolgozóegység hajtja végre őket.
- Párhuzamosság az, amikor két vagy több feladat ugyanabban az időben indulhat és futhat, egymástól függetlenül, külön feldolgozóegységeken.
A teljesség kedvéért íme a szinkron végrehajtás definíciója:
- Szinkron végrehajtás az, amikor egy feladatnak meg kell várnia, hogy egy másik futó feladat befejeződjön, mielőtt elindulhat.
Párhuzamosság JavaScriptben
Bár a JavaScript alapértelmezés szerint egyszálas, van mód a kód párhuzamos végrehajtására.
Ha böngészőben futtatod a JavaScriptet (például egy webalkalmazásban),
akkor a párhuzamosságot a Web Worker API segítségével érheted el.
Ahogy az MDN leírja:
A Web Workers lehetővé teszi, hogy egy szkriptműveletet a háttérszálon futtass, elkülönítve az alkalmazás fő végrehajtási szálától.
Ha viszont a JavaScripted Node.js-ben fut, ami az Exercism cél-futtatókörnyezete,
ugyanezt a fogalmat Worker threads néven ismerik.
Be aware that the implementation of the worker API differs largely between browsers and other JavaScript environments.
Make sure to read the documentation for your specific runtime!
Íme a Web Worker API egyszerű bemutatója (Medium nyomán)
// main.js
const myWorker = new Worker('worker.js');
myWorker.postMessage(5);
myWorker.onmessage = function (event) {
console.log('Received result from worker:', event.data);
};
// worker.js
onmessage = function (event) {
console.log('Received number from main thread:', event.data);
// Perform computation
const result = event.data * 2;
// Send result back to the main thread
postMessage(result);
};
És íme a Worker threads API bemutatója (a dokumentációból)
const {
Worker,
isMainThread,
parentPort,
workerData,
} = require('node:worker_threads');
if (isMainThread) {
module.exports = function parseJSAsync(script) {
return new Promise((resolve, reject) => {
const worker = new Worker(__filename, {
workerData: script,
});
worker.on('message', resolve);
worker.on('error', reject);
worker.on('exit', (code) => {
if (code !== 0)
reject(new Error(`Worker stopped with exit code ${code}`));
});
});
};
} else {
const { parse } = require('some-js-parsing-library');
const script = workerData;
parentPort.postMessage(parse(script));
}
Currently it is not possible to implement parallelism using the online editor.
Please implement `Worker threads` using Node.js locally and submit your solution via CLI!
Bónuszként gondold át, hogy a megoldásod átalakítható-e úgy, hogy kihasználja a Worker threads lehetőségeit.
További olvasmányok
