Какво е паралелизъм в JavaScript?

JavaScript може да се бори със задачи, изискващи висока производителност, тъй като е език с една нишка. Използвайки паралелизъм, можете да постигнете многонишково изпълнение в JavaScript и да подобрите производителността и отзивчивостта на вашите модерни уеб приложения.

Паралелизъм в програмирането на JavaScript

Паралелизмът е от решаващо значение в съвременните компютри за подобряване на производителността и скалируемостта. Той прави това чрез ефективно използване на наличните ресурси.

Обичайна техника, използвана за постигане на паралелизъм в програмирането, е многопоточността. Нишката на JavaScript обаче е система с една нишка и може да обработва само една задача наведнъж. Това означава, че не е запознат с паралелното изпълнение на програми.

JavaScript фалшифицира паралелното програмиране

Често срещано погрешно схващане за паралелизма е, че можете да го постигнете, като използвате

техники за асинхронно програмиране като async/await, обратни извиквания и обещания:

// Async/await функция, която симулира мрежова заявка
асинхроненфункцияfetchData() {
конст отговор = изчакайте извличане ();
конст данни = изчакайте response.json();
връщане данни;
}
// Функция за обратно извикване, която регистрира извлечените данни в конзолата
функцияlogData(данни) {
конзола.log (данни);
}
// Promise.all() метод, който изпълнява множество обещания паралелно
обещание.всичко([
 fetchData(),
 fetchData(),
]).тогава((резултати) => {
конзола.log (резултати);
});
// Извикване на функцията fetchData и предаване на функцията logData като обратно извикване
fetchData().след това (logData);

Тези техники всъщност не изпълняват код паралелно. JavaScript използва цикъла на събитията, за да имитира паралелно програмиране в рамките на своя дизайн с една нишка.

Цикълът на събития е основна част от средата за изпълнение на JavaScript. Позволява ви да изпълнявате асинхронни операции, като мрежови заявки, във фонов режим, без да блокирате основната единична нишка.

Цикълът на събитията постоянно проверява за нови събития или задачи в опашка и ги изпълнява последователно едно по едно. Тази техника позволява на JavaScript да постигне едновременност и теоретичен паралелизъм.

Паралелност срещу Паралелизъм

Паралелността и паралелността често се разбират погрешно и се разменят в света на JavaScript.

Паралелността в JavaScript се отнася до възможността за изпълнение на множество задачи чрез припокриване на изпълнението на задачите. Когато една задача може да започне, преди друга да завърши, но задачите не могат нито да започнат, нито да завършат едновременно. Това позволява на JavaScript ефективно да обработва операции, като извличане на данни от REST API или четене на файлове, без блокиране на основната нишка за изпълнение.

Паралелизмът, от друга страна, се отнася до способността да се изпълняват множество задачи едновременно в множество нишки. Тези фонови нишки могат да изпълняват задачи независимо и едновременно. Това отваря възможности за постигане на истински паралелизъм в приложенията на JavaScript.

Приложенията на JavaScript могат да постигнат истински паралелизъм чрез използването на Web Workers.

Уеб работниците въвеждат паралелизъм в JavaScript

Web Workers са характеристика на съвременните уеб браузъри, която позволява JavaScript кодът да се изпълнява във фонови нишки, отделно от основната нишка за изпълнение. За разлика от основната нишка, която обработва потребителските взаимодействия и актуализациите на потребителския интерфейс. Web Worker ще бъде посветен на изпълнението на изчислително интензивни задачи.

По-долу е представена диаграма на работата на Web Worker в JavaScript.

Главната нишка и Web Worker могат да комуникират чрез предаване на съобщения. Използвайки postMessage метод за изпращане на съобщения и onmessage манипулатор на събития за получаване на съобщения, можете да предавате инструкции или данни напред и назад.

Създаване на Web Worker

За да създадете Web Worker, трябва да създадете отделен JavaScript файл.

Ето един пример:

// main.js
// Създаване на нов уеб работник
конст работник = нов работник('worker.js');
// Изпращане на съобщение до Web Worker
worker.postMessage(„Здравейте от основната тема!“);
// Слушайте за съобщения от Web Worker
worker.onmessage = функция(събитие) {
конзола.log(„Получено съобщение от Web Worker:“, събитие.данни);
};

Горният пример създава нов Web Worker чрез предаване на пътя към работния скрипт (worker.js) като аргумент за работник конструктор. Можете да изпратите съобщение до Web Worker, като използвате postMessage и слушайте за съобщения от Web Worker, като използвате onmessage манипулатор на събития.

След това трябва да създадете работния скрипт (worker.js) файл:

// worker.js
// Слушане за съобщения от основната нишка
self.onmessage = функция(събитие) {
конзола.log(„Получено съобщение от основната нишка:“, събитие.данни);
// Изпращане на съобщение обратно към основната нишка
 self.postMessage(„Здравейте от worker.js!“);
};

Скриптът Web Worker слуша за съобщения от основната нишка, използвайки onmessage манипулатор на събития. При получаване на съобщение вие ​​излизате от съобщението вътре събитие.данни и изпратете ново съобщение до главната нишка с postMessage метод.

Използване на паралелизъм с уеб работници

Основният случай на използване на Web Workers е паралелното изпълнение на изчислително интензивни JavaScript задачи. Като прехвърлите тези задачи на Web Workers, можете да постигнете значителни подобрения в производителността.

Ето пример за използване на уеб работник за извършване на тежки изчисления:

// main.js
конст работник = нов работник('worker.js');
// Изпращане на данни до Web Worker за изчисление
worker.postMessage([1, 2, 3, 4, 5]);
// Слушайте резултата от Web Worker
worker.onmessage = функция(събитие) {
конст резултат = събитие.данни;
конзола.log(„Резултат от изчислението:“, резултат);
};

Worker.js:

// Слушайте за данни от основната нишка
self.onmessage = функция (събитие) {
конст числа = събитие.данни;
конст резултат = изпълни HeavyCalculation (числа);
// Изпращане на резултата обратно в основната нишка
 self.postMessage (резултат);
};
функцияизпълни тежко изчисление(данни) {
// Извършване на сложно изчисление върху масива от числа
връщане данни
 .map((номер) =>математика.pow (номер, 3)) // Куб всяко число
 .filter((номер) => брой % 20) // Филтриране на четни числа
 .намаляване((сума, число) => сбор + число, 0); // Сумиране на всички числа
}

В този пример предавате масив от числа от основната нишка към Web Worker. Web Worker извършва изчислението, като използва предоставения масив от данни и изпраща резултата обратно към основната нишка. The изпълни HeavyCalculation() функция преобразува всяко число в неговия куб, филтрира четните числа и накрая ги сумира.

Ограничения и съображения

Въпреки че Web Workers осигуряват механизъм за постигане на паралелизъм в JavaScript, важно е да вземете предвид няколко ограничения и съображения:

• Няма споделена памет: Уеб работниците работят в отделни нишки и не споделят памет с основната нишка. Така че те не могат директно да имат достъп до променливи или обекти от главната нишка без предаване на съобщение.
• Сериализация и десериализация: Когато предавате данни между основната нишка и Web Workers, трябва да сериализирате и десериализирате данните, тъй като предаването на съобщения е текстово базирана комуникация. Този процес води до разходи за производителност и може да повлияе на цялостната производителност на приложението.
• Поддръжка на браузър: Въпреки че Web Workers се поддържат добре в повечето съвременни уеб браузъри, някои по-стари браузъри или ограничени среди може да имат частична или никаква поддръжка за Web Workers.

Постигнете истински паралелизъм в JavaScript

Паралелизмът в JavaScript е вълнуваща концепция, която позволява истинско едновременно изпълнение на задачи, дори в предимно еднонишков език. С въвеждането на Web Workers можете да се възползвате от силата на паралелизма и да постигнете значителни подобрения в производителността на вашите JavaScript приложения.