Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne
Równoległe wykonywanie zadań asynchronicznych
W tej lekcji10
W Parku Jurajskim, jednoczesne zarządzanie wieloma systemami i monitorowanie dziesiątek dinozaurów wymaga wydajnego podejścia do wykonywania wielu zadań jednocześnie. W tym ćwiczeniu skupimy się na technikach równoległego wykonywania zadań asynchronicznych w JavaScript, co pozwoli nam zwiększyć wydajność naszych systemów zarządzania parkiem.
Dlaczego równoległe wykonywanie jest ważne?
Wyobraźmy sobie, że musimy sprawdzić status wszystkich 50 wybiegów dinozaurów przed otwarciem parku. Jeśli każde sprawdzenie zajmuje około 1 sekundy i wykonujemy je sekwencyjnie (jedno po drugim), cały proces zajmie co najmniej 50 sekund - zdecydowanie za długo przed wpuszczeniem odwiedzających!
Wykonując te zadania równolegle, możemy znacznie skrócić całkowity czas potrzebny na przeprowadzenie wszystkich operacji, ograniczając go do czasu trwania najdłuższej pojedynczej operacji (plus pewien narzut).
Promise.all() - podstawowe narzędzie do równoległego wykonywania
Jak już widzieliśmy w poprzednich lekcjach, Promise.all() jest podstawowym narzędziem do równoległego wykonywania wielu zadań asynchronicznych:
async function sprawdźStatusWszystkichWybiegów() {
const listaWybiegów = await pobierzListęWybiegów();
console.log(`Sprawdzanie statusu ${listaWybiegów.length} wybiegów...`);
const startTime = Date.now();
// Uruchomienie sprawdzania wszystkich wybiegów równolegle
const wyniki = await Promise.all(
listaWybiegów.map(wybieg => sprawdźStatusWybiegu(wybieg.id))
);
const czasWykonania = (Date.now() - startTime) / 1000;
console.log(`Sprawdzenie wszystkich wybiegów zajęło ${czasWykonania.toFixed(2)} sekund`);
// Analizuj wyniki
const bezpieczneWybiegi = wyniki.filter(w => w.status === 'secure');
const problematyczneWybiegi = wyniki.filter(w => w.status !== 'secure');
console.log(`Bezpieczne wybiegi: ${bezpieczneWybiegi.length}`);
console.log(`Problematyczne wybiegi: ${problematyczneWybiegi.length}`);
if (problematyczneWybiegi.length > 0) {
console.warn("Znaleziono problemy w następujących wybiegach:");
problematyczneWybiegi.forEach(w => {
console.warn(`- Wybieg #${w.id}: ${w.status} (${w.message})`);
});
}
return {
wszystkie: wyniki.length,
bezpieczne: bezpieczneWybiegi.length,
problematyczne: problematyczneWybiegi,
czasWykonania
};
}W powyższym przykładzie, używamy Promise.all() do równoległego sprawdzenia statusu wszystkich wybiegów. Zamiast czekać na zakończenie każdego sprawdzenia przed rozpoczęciem następnego, wszystkie sprawdzenia są inicjowane jednocześnie, a my czekamy na zakończenie wszystkich.
Wyzwania związane z równoległym wykonywaniem
Równoległe wykonywanie zadań asynchronicznych przynosi wiele korzyści, ale wiąże się także z pewnymi wyzwaniami:
1. Zarządzanie zasobami
Uruchomienie zbyt wielu operacji równolegle może przeciążyć dostępne zasoby systemowe (pamięć, połączenia sieciowe, itp.).
2. Obsługa błędów
Pamiętaj, że Promise.all() zakończy się niepowodzeniem, jeśli którakolwiek z obietnic zostanie odrzucona. W przypadku dużej liczby równoległych operacji, jeden błąd może spowodować niepowodzenie całego procesu.
3. Zbyt dużo równoległości
Nie zawsze uruchamianie wszystkich zadań równolegle jest najlepszym rozwiązaniem. Czasami potrzebujemy kontrolować maksymalną liczbę równoległych operacji.
Kontrolowanie liczby równoległych operacji
W sytuacjach, gdy mamy do wykonania wiele zadań, ale nie chcemy uruchamiać ich wszystkich jednocześnie, możemy zastosować technikę "równoległości z ograniczeniem":
/**
* Wykonuje tablicę zadań z ograniczoną liczbą równoległych operacji
* @param {Function[]} zadania - Tablica funkcji, które zwracają Promise
* @param {number} maxRównoległe - Maksymalna liczba równoległych operacji
* @returns {Promise<any[]>} - Promise z tablicą wyników
*/
async function wykonajZOgraniczonaRownoleglością(zadania, maxRównoległe) {
// Tablica dla wszystkich wyników
const wyniki = [];
// Tablica dla aktywnych zadań
const aktywneZadania = new Set();
// Indeks bieżącego zadania
let indeksZadania = 0;
// Funkcja pomocnicza do uruchamiania zadań
const uruchomZadanie = async (indeks) => {
// Dodanie zadania do aktywnych
const zadanie = zadania[indeks];
aktywneZadania.add(indeks);
try {
// Wykonanie zadania
const wynik = await zadanie();
wyniki[indeks] = { status: 'fulfilled', value: wynik };
} catch (error) {
wyniki[indeks] = { status: 'rejected', reason: error };
} finally {
// Usunięcie zadania z aktywnych
aktywneZadania.delete(indeks);
// Jeśli są jeszcze zadania do wykonania, uruchom następne
if (indeksZadania < zadania.length) {
uruchomZadanie(indeksZadania++);
} else if (aktywneZadania.size === 0) {
// Jeśli nie ma więcej zadań i wszystkie aktywne zakończone, zakończ
return;
}
}
};
// Uruchom początkową pulę zadań
const początkowe = Math.min(maxRównoległe, zadania.length);
for (let i = 0; i < początkowe; i++) {
uruchomZadanie(indeksZadania++);
}
// Czekaj na zakończenie wszystkich zadań
await new Promise(resolve => {
const interval = setInterval(() => {
if (indeksZadania >= zadania.length && aktywneZadania.size === 0) {
clearInterval(interval);
resolve();
}
}, 100);
});
return wyniki;
}
// Przykład użycia
async function monitorujDinozaury() {
const listaDinozaurów = await pobierzListęDinozaurów();
// Tworzymy tablicę funkcji, które zwracają Promise
const zadania = listaDinozaurów.map(dino => {
return async () => {
console.log(`Rozpoczynam monitorowanie dinozaura #${dino.id}...`);
const wynik = await monitorujDinozaura(dino.id);
console.log(`Zakończono monitorowanie dinozaura #${dino.id}`);
return wynik;
};
});
console.log(`Monitorowanie ${zadania.length} dinozaurów z maksymalnie 5 równolegle...`);
const wyniki = await wykonajZOgraniczonaRownoleglością(zadania, 5);
// Analiza wyników
const udane = wyniki.filter(w => w.status === 'fulfilled').length;
const nieudane = wyniki.filter(w => w.status === 'rejected').length;
console.log(`Ukończono monitorowanie: ${udane} udanych, ${nieudane} nieudanych`);
return {
wszystkie: wyniki.length,
udane,
nieudane,
wyniki
};
}W powyższym przykładzie, wykonajZOgraniczonaRownoleglością zapewnia, że w dowolnym momencie wykonywanych jest maksymalnie maxRównoległe zadań. Gdy jedno zadanie zostaje zakończone, automatycznie uruchamiane jest kolejne z kolejki.
Biblioteki pomagające w zarządzaniu równoległością
Istnieje kilka popularnych bibliotek, które ułatwiają zarządzanie równoległym wykonywaniem zadań:
p-limit
Biblioteka p-limit pozwala na łatwe ograniczenie liczby równoległych operacji:
const pLimit = require('p-limit');
async function monitorujWszystkieDinozaury() {
const listaDinozaurów = await pobierzListęDinozaurów();
// Utwórz instancję limitera z maksymalnie 5 równoległymi operacjami
const limit = pLimit(5);
// Utwórz tablicę obietnic z ograniczoną równoległością
const obietnice = listaDinozaurów.map(dino => {
return limit(() => monitorujDinozaura(dino.id));
});
// Czekaj na zakończenie wszystkich operacji
const wyniki = await Promise.all(obietnice);
return wyniki;
}async
Biblioteka async oferuje szeroki zestaw narzędzi do zarządzania zadaniami asynchronicznymi:
const async = require('async');
async function uruchomDiagnostykęSystemów() {
const systemy = [
{ id: 'ogrodzenie', nazwa: 'System ogrodzeń elektrycznych' },
{ id: 'kamery', nazwa: 'System monitoringu wideo' },
{ id: 'czujniki', nazwa: 'System czujników ruchu' },
// ... więcej systemów
];
// Wywołaj diagnostykę dla maksymalnie 3 systemów równolegle
const wyniki = await new Promise((resolve, reject) => {
async.mapLimit(
systemy,
3,
async (system) => {
console.log(`Uruchamiam diagnostykę systemu: ${system.nazwa}...`);
const wynik = await diagnostykaSystemu(system.id);
console.log(`Zakończono diagnostykę systemu: ${system.nazwa}`);
return { system, wynik };
},
(err, results) => {
if (err) reject(err);
else resolve(results);
}
);
});
return wyniki;
}Strategie równoległego przetwarzania
Poniżej znajduje się kilka użytecznych strategii równoległego przetwarzania, które można zastosować w różnych scenariuszach:
1. Przetwarzanie wsadowe
Zamiast przetwarzać wszystkie elementy naraz, możemy podzielić je na mniejsze partie i przetwarzać każdą partię równolegle:
async function przetworzyćWszystkieDaneWPartie(elementy, wielkośćPartii = 10) {
const wyniki = [];
// Podziel elementy na partie
for (let i = 0; i < elementy.length; i += wielkośćPartii) {
const partia = elementy.slice(i, i + wielkośćPartii);
console.log(`Przetwarzanie partii ${Math.floor(i / wielkośćPartii) + 1}/${Math.ceil(elementy.length / wielkośćPartii)}...`);
// Przetwórz wszystkie elementy z bieżącej partii równolegle
const wynikiPartii = await Promise.all(
partia.map(element => przetwórzElement(element))
);
wyniki.push(...wynikiPartii);
}
return wyniki;
}
// Przykład użycia
async function aktualizujDaneWszystkichDinozaurów(noweDane) {
const listaDinozaurów = await pobierzListęDinozaurów();
console.log(`Aktualizowanie danych dla ${listaDinozaurów.length} dinozaurów w partiach po 20...`);
const wyniki = await przetworzyćWszystkieDaneWPartie(
listaDinozaurów.map(dino => ({ id: dino.id, ...noweDane })),
20
);
console.log(`Zakończono aktualizację danych dla ${wyniki.length} dinozaurów`);
return wyniki;
}2. Kolejkowanie zadań priorytetowych
Czasami niektóre zadania są ważniejsze od innych i powinny być wykonywane w pierwszej kolejności:
class KolejkaPriorytetowa {
constructor() {
// Mapa kolejek dla różnych priorytetów
this.kolejki = new Map();
// Aktualnie przetwarzane zadania
this.aktywne = new Set();
// Maksymalna liczba równoległych zadań
this.maxRównoległe = 5;
// Czy kolejka jest aktywna
this.aktywna = false;
}
// Dodaj zadanie do kolejki
dodajZadanie(zadanie, priorytet = 1) {
if (!this.kolejki.has(priorytet)) {
this.kolejki.set(priorytet, []);
}
this.kolejki.get(priorytet).push(zadanie);
// Jeśli kolejka jest aktywna, spróbuj uruchomić zadania
if (this.aktywna) {
this.przetwarzajZadania();
}
}
// Rozpocznij przetwarzanie zadań
rozpocznij() {
this.aktywna = true;
this.przetwarzajZadania();
}
// Zatrzymaj przetwarzanie zadań
zatrzymaj() {
this.aktywna = false;
}
// Przetwarzaj zadania
async przetwarzajZadania() {
if (!this.aktywna) return;
// Sprawdź, czy możemy uruchomić więcej zadań
while (this.aktywne.size < this.maxRównoległe) {
// Pobierz zadanie o najwyższym priorytecie
const zadanie = this.pobierzNastępneZadanie();
if (!zadanie) {
// Brak zadań do przetworzenia
break;
}
// Utwórz unikalny identyfikator zadania
const id = Symbol();
// Dodaj zadanie do aktywnych
this.aktywne.add(id);
// Uruchom zadanie
zadanie()
.catch(error => {
console.error("Błąd zadania:", error);
})
.finally(() => {
// Usuń zadanie z aktywnych
this.aktywne.delete(id);
// Kontynuuj przetwarzanie
this.przetwarzajZadania();
});
}
}
// Pobierz zadanie o najwyższym priorytecie
pobierzNastępneZadanie() {
// Sortuj priorytety malejąco
const priorytety = [...this.kolejki.keys()].sort((a, b) => b - a);
for (const priorytet of priorytety) {
const kolejka = this.kolejki.get(priorytet);
if (kolejka.length > 0) {
return kolejka.shift();
}
}
return null;
}
// Sprawdź, czy wszystkie zadania zostały zakończone
czyWszystkoZakończone() {
return this.aktywne.size === 0 &&
[...this.kolejki.values()].every(kolejka => kolejka.length === 0);
}
// Czekaj na zakończenie wszystkich zadań
async czekajNaZakończenie() {
if (this.czyWszystkoZakończone()) {
return;
}
return new Promise(resolve => {
const interwał = setInterval(() => {
if (this.czyWszystkoZakończone()) {
clearInterval(interwał);
resolve();
}
}, 100);
});
}
}
// Przykład użycia
async function monitorujParkZPriorytetami() {
const kolejka = new KolejkaPriorytetowa();
// Dodawanie zadań z różnymi priorytetami
// Priorytet najwyższy (3) - systemy bezpieczeństwa
kolejka.dodajZadanie(
async () => {
console.log("Sprawdzanie systemów bezpieczeństwa...");
return await sprawdźSystemyBezpieczeństwa();
},
3
);
// Priorytet średni (2) - drapieżniki
const drapieżniki = await pobierzListęDrapieżników();
drapieżniki.forEach(dino => {
kolejka.dodajZadanie(
async () => {
console.log(`Monitorowanie drapieżnika #${dino.id}...`);
return await monitorujDinozaura(dino.id);
},
2
);
});
// Priorytet normalny (1) - roślinożercy
const roślinożercy = await pobierzListęRoślinożerców();
roślinożercy.forEach(dino => {
kolejka.dodajZadanie(
async () => {
console.log(`Monitorowanie roślinożercy #${dino.id}...`);
return await monitorujDinozaura(dino.id);
},
1
);
});
// Rozpocznij przetwarzanie
console.log("Rozpoczynam monitorowanie parku z priorytetyzacją zadań...");
kolejka.rozpocznij();
// Czekaj na zakończenie wszystkich zadań
await kolejka.czekajNaZakończenie();
console.log("Monitorowanie parku zakończone");
}3. Przetwarzanie strumieniowe
W przypadku dużych zbiorów danych, które pojawiają się w czasie, przetwarzanie strumieniowe może być bardziej efektywne:
async function* generatorDanychDinozaurów() {
const strumień = await otwórzStrumieńDanych('/var/log/dino-sensors.log');
for await (const linia of strumień) {
// Przetwarzanie i parsowanie linii danych
const dane = JSON.parse(linia);
yield dane;
}
}
async function monitorujStrumieńDanychDinozaurów() {
const wyniki = [];
const aktywnePromisy = new Set();
const maxRównoległe = 10;
async function przetwórzDane(dane) {
try {
// Przetwarzanie danych i aktualizacja statusu
const wynik = await aktualizujStatusDinozaura(dane.dinoId, dane);
wyniki.push({ id: dane.dinoId, status: 'success', result: wynik });
} catch (error) {
wyniki.push({ id: dane.dinoId, status: 'error', error: error.message });
}
}
for await (const dane of generatorDanychDinozaurów()) {
// Czekaj, jeśli osiągnięto maksymalną liczbę równoległych operacji
if (aktywnePromisy.size >= maxRównoległe) {
await Promise.race(aktywnePromisy);
}
// Utwórz nowy promise i śledź go
const promisa = przetwórzDane(dane);
aktywnePromisy.add(promisa);
// Po zakończeniu, usuń z aktywnych
promisa.finally(() => {
aktywnePromisy.delete(promisa);
});
}
// Czekaj na zakończenie wszystkich aktywnych obietnic
if (aktywnePromisy.size > 0) {
await Promise.all(aktywnePromisy);
}
return wyniki;
}Równoległe przetwarzanie z obsługą błędów
Jak wspomnieliśmy wcześniej, Promise.all() zawiedzie, jeśli którakolwiek z obietnic zostanie odrzucona. W niektórych przypadkach chcemy kontynuować przetwarzanie, nawet jeśli niektóre operacje zakończą się niepowodzeniem.
W ECMAScript 2020, wprowadzono Promise.allSettled(), które rozwiązuje ten problem:
async function uruchomDiagnostykęWszystkichSystemów() {
const systemy = await pobierzWszystkieSystemy();
console.log(`Uruchamianie diagnostyki dla ${systemy.length} systemów...`);
// Uruchom diagnostykę wszystkich systemów równolegle i poczekaj na zakończenie wszystkich
const wyniki = await Promise.allSettled(
systemy.map(async (system) => {
try {
console.log(`Diagnostyka systemu ${system.name}...`);
const wynik = await diagnostykaSystemu(system.id);
console.log(`Diagnostyka systemu ${system.name} zakończona`);
return { systemId: system.id, status: 'success', result: wynik };
} catch (error) {
console.error(`Błąd diagnostyki systemu ${system.name}:`, error);
return { systemId: system.id, status: 'error', error: error.message };
}
})
);
// Analiza wyników
const udane = wyniki.filter(w => w.status === 'fulfilled' && w.value.status === 'success');
const nieudane = wyniki.filter(w => w.status === 'rejected' || (w.status === 'fulfilled' && w.value.status === 'error'));
console.log(`Diagnostyka zakończona: ${udane.length} udanych, ${nieudane.length} nieudanych`);
if (nieudane.length > 0) {
console.warn("Systemy z problemami:");
nieudane.forEach(w => {
if (w.status === 'rejected') {
console.warn(`- System #${w.systemId}: Błąd krytyczny: ${w.reason}`);
} else {
console.warn(`- System #${w.value.systemId}: ${w.value.error}`);
}
});
}
return {
wszystkie: wyniki.length,
udane: udane.length,
nieudane: nieudane.length,
wyniki
};
}Zaawansowane techniki równoległego przetwarzania
1. Worker Threads w Node.js
W Node.js, możemy użyć modułu worker_threads do wykonywania obliczeń intensywnych w oddzielnych wątkach:
const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
// Główny kod
if (isMainThread) {
async function analizujDaneDinozaurów() {
const dane = await pobierzDużeZbioryDanych();
// Podziel dane na części, jedną dla każdego rdzenia CPU
const ilośćWątków = require('os').cpus().length;
const częściDanych = podzielDane(dane, ilośćWątków);
// Utwórz worker dla każdej części danych
const workers = częściDanych.map((część, indeks) => {
return new Promise((resolve, reject) => {
const worker = new Worker(__filename, {
workerData: { dane: część, indeks }
});
worker.on('message', resolve);
worker.on('error', reject);
worker.on('exit', (code) => {
if (code !== 0) {
reject(new Error(`Worker stopped with exit code ${code}`));
}
});
});
});
// Czekaj na zakończenie wszystkich workerów
const wyniki = await Promise.all(workers);
// Połącz wyniki
return połączWyniki(wyniki);
}
} else {
// Kod wykonywany w każdym wątku pracownika
const { dane, indeks } = workerData;
// Przeprowadź złożone obliczenia na danych
const wyniki = przetwórzDane(dane);
// Wyślij wyniki z powrotem do głównego wątku
parentPort.postMessage(wyniki);
}2. Web Workers w przeglądarce
W środowisku przeglądarki, możemy użyć Web Workers do wykonywania zadań w tle:
// main.js - główny kod w przeglądarce
function uruchomAnalizęDNA() {
const dnaSamples = pobierzPróbkiDNA();
// Podziel próbki na grupy
const groupSize = Math.ceil(dnaSamples.length / 4); // 4 grupy
const groups = [];
for (let i = 0; i < dnaSamples.length; i += groupSize) {
groups.push(dnaSamples.slice(i, i + groupSize));
}
// Utwórz worker dla każdej grupy
const workers = groups.map((group, index) => {
return new Promise((resolve, reject) => {
const worker = new Worker('dna-worker.js');
worker.onmessage = function(e) {
resolve(e.data);
worker.terminate();
};
worker.onerror = function(e) {
reject(new Error(e.message));
worker.terminate();
};
worker.postMessage({
samples: group,
groupId: index
});
});
});
// Czekaj na wyniki ze wszystkich workerów
return Promise.all(workers)
.then(results => {
// Połącz wyniki
return results.flat();
});
}
// dna-worker.js - kod workera
self.onmessage = function(e) {
const { samples, groupId } = e.data;
// Wykonaj złożoną analizę DNA
const results = samples.map(sample => analyzeDNASample(sample));
// Wyślij wyniki z powrotem do głównego wątku
self.postMessage(results);
};
function analyzeDNASample(sample) {
// Symulacja złożonej analizy
//
return {
sampleId: sample.id,
species: determineSpecies(sample.dna),
genomeMap: mapGenome(sample.dna),
//
};
}Strategie zarządzania zasobami
Gdy wykonujemy wiele zadań równolegle, ważne jest zarządzanie dostępnymi zasobami:
1. Monitorowanie zużycia zasobów
async function wykonajZMonitorowaniemZasobów(zadania, opcje = {}) {
const {
maxRównoległe = 5,
maxPamięć = 1024 * 1024 * 1024, // 1GB
interwałMonitorowania = 1000 // 1s
} = opcje;
const aktywneZadania = new Set();
const zakończoneZadania = [];
let indeksZadania = 0;
// Uruchom początkowe zadania
for (let i = 0; i < Math.min(maxRównoległe, zadania.length); i++) {
uruchomZadanie(indeksZadania++);
}
// Monitorowanie zasobów
const interwał = setInterval(() => {
const wykorzystaniePamięci = process.memoryUsage().heapUsed;
// Jeśli zużycie pamięci jest zbyt wysokie, wstrzymaj uruchamianie nowych zadań
if (wykorzystaniePamięci > maxPamięć && aktywneZadania.size > 1) {
console.warn(`Wysokie zużycie pamięci: ${(wykorzystaniePamięci / 1024 / 1024).toFixed(2)} MB. Zwalnianie...`);
// Nie uruchamiaj nowych zadań, dopóki pamięć nie zostanie zwolniona
}
// Sprawdź, czy wszystkie zadania zostały zakończone
if (indeksZadania >= zadania.length && aktywneZadania.size === 0) {
clearInterval(interwał);
}
}, interwałMonitorowania);
async function uruchomZadanie(indeks) {
if (indeks >= zadania.length) {
return;
}
const identyfikator = Symbol();
aktywneZadania.add(identyfikator);
try {
const wynik = await zadania[indeks]();
zakończoneZadania[indeks] = { status: 'fulfilled', value: wynik };
} catch (error) {
zakończoneZadania[indeks] = { status: 'rejected', reason: error };
} finally {
aktywneZadania.delete(identyfikator);
// Sprawdź wykorzystanie pamięci przed uruchomieniem kolejnego zadania
const wykorzystaniePamięci = process.memoryUsage().heapUsed;
if (wykorzystaniePamięci < maxPamięć || aktywneZadania.size === 0) {
// Uruchom kolejne zadanie, jeśli pamięć pozwala lub nie ma aktywnych zadań
if (indeksZadania < zadania.length) {
uruchomZadanie(indeksZadania++);
}
}
}
}
// Czekaj na zakończenie wszystkich zadań
while (zakończoneZadania.length < zadania.length) {
await new Promise(resolve => setTimeout(resolve, 100));
}
clearInterval(interwał);
return zakończoneZadania;
}2. Dynamiczne dostosowywanie równoległości
W zależności od bieżącego obciążenia systemu, możemy dynamicznie dostosowywać poziom równoległości:
class AdaptiveTaskProcessor {
constructor(options = {}) {
this.minParallelism = options.minParallelism || 1;
this.maxParallelism = options.maxParallelism || 10;
this.currentParallelism = options.startParallelism || 5;
this.tasks = [];
this.activeTasks = new Set();
this.completedTasks = [];
this.running = false;
this.performanceHistory = [];
this.adaptationInterval = options.adaptationInterval || 5000; // 5s
}
addTask(task) {
this.tasks.push(task);
if (this.running) {
this.processQueue();
}
}
async start() {
this.running = true;
this.processQueue();
// Start adaptation
this.adaptationTimer = setInterval(() => {
this.adaptParallelism();
}, this.adaptationInterval);
}
stop() {
this.running = false;
clearInterval(this.adaptationTimer);
}
async processQueue() {
if (!this.running) return;
while (this.activeTasks.size < this.currentParallelism && this.tasks.length > 0) {
const task = this.tasks.shift();
await this.executeTask(task);
}
}
async executeTask(task) {
const id = Symbol();
this.activeTasks.add(id);
const startTime = Date.now();
try {
const result = await task();
this.completedTasks.push({
status: 'fulfilled',
value: result,
duration: Date.now() - startTime
});
} catch (error) {
this.completedTasks.push({
status: 'rejected',
reason: error,
duration: Date.now() - startTime
});
} finally {
this.activeTasks.delete(id);
// Add to performance history
this.performanceHistory.push({
parallelism: this.currentParallelism,
duration: Date.now() - startTime
});
// Trim history to last 100 tasks
if (this.performanceHistory.length > 100) {
this.performanceHistory.shift();
}
this.processQueue();
}
}
adaptParallelism() {
if (this.performanceHistory.length < 10) {
// Not enough data to adapt
return;
}
// Calculate average task duration for current parallelism
const recentTasks = this.performanceHistory.slice(-20);
const avgDuration = recentTasks.reduce((sum, t) => sum + t.duration, 0) / recentTasks.length;
// Check if we've tracked different parallelism levels
const levels = new Set(this.performanceHistory.map(t => t.parallelism));
if (levels.size < 2) {
// Try a different parallelism level
this.currentParallelism = Math.max(
this.minParallelism,
Math.min(
this.maxParallelism,
this.currentParallelism + (Math.random() > 0.5 ? 1 : -1)
)
);
console.log(`Adjusting parallelism to ${this.currentParallelism} (exploration)`);
return;
}
// Group by parallelism level
const byLevel = {};
this.performanceHistory.forEach(t => {
if (!byLevel[t.parallelism]) {
byLevel[t.parallelism] = [];
}
byLevel[t.parallelism].push(t.duration);
});
// Calculate average duration per parallelism level
const avgByLevel = {};
Object.entries(byLevel).forEach(([level, durations]) => {
avgByLevel[level] = durations.reduce((sum, d) => sum + d, 0) / durations.length;
});
// Find the best parallelism level
const bestLevel = Object.entries(avgByLevel)
.sort(([, durationA], [, durationB]) => durationA - durationB)[0][0];
const newParallelism = parseInt(bestLevel, 10);
if (newParallelism !== this.currentParallelism) {
console.log(`Adjusting parallelism to ${newParallelism} (optimization)`);
this.currentParallelism = newParallelism;
}
}
async waitForAll() {
this.stop();
while (this.tasks.length > 0 || this.activeTasks.size > 0) {
await new Promise(resolve => setTimeout(resolve, 100));
}
return this.completedTasks;
}
}
// Przykład użycia
async function wykonajZadaniaZAdaptacją() {
const processor = new AdaptiveTaskProcessor({
minParallelism: 1,
maxParallelism: 20,
startParallelism: 5
});
// Dodaj zadania
for (let i = 0; i < 100; i++) {
processor.addTask(async () => {
const zadanieId = i;
console.log(`Rozpoczęcie zadania #${zadanieId}`);
// Symulacja zadania o różnej złożoności
const złożoność = Math.random() * 1000 + 500;
await new Promise(resolve => setTimeout(resolve, złożoność));
console.log(`Zakończenie zadania #${zadanieId}`);
return { zadanieId, złożoność };
});
}
// Uruchom przetwarzanie
processor.start();
// Czekaj na zakończenie
const wyniki = await processor.waitForAll();
console.log(`Zakończono wszystkie zadania. Wyniki: ${wyniki.length}`);
return wyniki;
}Podsumowanie
Równoległe wykonywanie zadań asynchronicznych jest kluczowym narzędziem w optymalizacji wydajności aplikacji JavaScript. W Parku Jurajskim, gdzie monitorowanie i zarządzanie wieloma systemami i dinozaurami wymaga szybkiej reakcji, właściwe wykorzystanie technik równoległego przetwarzania może znacznie poprawić responsywność i skalowalność systemu.
Poznaliśmy kilka ważnych technik i wzorców:
- Promise.all() - podstawowe narzędzie do równoległego wykonywania wielu zadań asynchronicznych
- Kontrolowanie liczby równoległych operacji - techniki ograniczania maksymalnej równoległości
- Przetwarzanie wsadowe - przetwarzanie danych w partiach
- Kolejkowanie zadań z priorytetami - wykonywanie ważniejszych zadań w pierwszej kolejności
- Przetwarzanie strumieniowe - przetwarzanie danych w miarę ich napływania
- Worker Threads i Web Workers - wykonywanie zadań w oddzielnych wątkach
- Adaptacyjne zarządzanie zasobami - dynamiczne dostosowywanie poziomu równoległości
Wybór odpowiedniej techniki zależy od konkretnego przypadku użycia, wymagań wydajnościowych oraz dostępnych zasobów. Pamiętaj, że nie zawsze więcej równoległości oznacza lepszą wydajność - zbyt wiele równoległych operacji może prowadzić do przeciążenia systemu, a w konsekwencji do pogorszenia ogólnej wydajności.
W praktyce, najlepsze wyniki często osiąga się przez eksperymentowanie z różnymi strategiami i poziomami równoległości, monitorowanie wydajności i odpowiednie dostosowywanie parametrów.
Kod do tej lekcji: index.js
// Hoisting Demonstration - Wynoszenie deklaracji
console.log("HOISTING W JAVASCRIPT\n");
console.log("=== HOISTING ZMIENNYCH ===\n");
// var jest hoistowany
console.log("1. dinosaurName przed deklaracją:", dinosaurName); // undefined (nie error!)
var dinosaurName = "T-Rex";
console.log("2. dinosaurName po deklaracji:", dinosaurName); // T-Rex
// Powyższy kod jest interpretowany jako:
// var dinosaurName; // deklaracja wyniesiona na górę
// console.log(dinosaurName); // undefined
// dinosaurName = "T-Rex"; // przypisanie
console.log("\n=== HOISTING let/const ===\n");
// let i const są w "temporal dead zone"
try {
console.log(species); // ReferenceError!
let species = "Velociraptor";
} catch (error) {
console.log("Błąd:", error.message);
}
console.log("\n=== HOISTING FUNKCJI ===\n");
// Function declaration jest w pełni hoistowany
console.log("Wywołanie przed deklaracją:");
feedDinosaur("T-Rex"); // Działa!
function feedDinosaur(name) {
console.log(`Karmienie ${name}`);
}
console.log("\nWywołanie po deklaracji:");
feedDinosaur("Triceratops");
console.log("\n=== FUNCTION EXPRESSION ===\n");
// Function expression NIE jest hoistowany
try {
checkSecurity("Sektor A"); // TypeError!
} catch (error) {
console.log("Błąd:", error.message);
}
var checkSecurity = function(sector) {
console.log(`Sprawdzanie ${sector}`);
};
// Teraz działa
checkSecurity("Sektor B");
console.log("\n=== PRZYKŁAD PRAKTYCZNY ===\n");
function demonstrateHoisting() {
console.log("Funkcja startuje");
console.log("Wartość x:", x); // undefined
if (true) {
var x = "Jestem var - function scoped";
let y = "Jestem let - block scoped";
const z = "Jestem const - block scoped";
console.log("W bloku - x:", x);
console.log("W bloku - y:", y);
console.log("W bloku - z:", z);
}
console.log("Po bloku - x:", x); // Działa!
// console.log("Po bloku - y:", y); // ERROR! y jest block scoped
// console.log("Po bloku - z:", z); // ERROR! z jest block scoped
}
demonstrateHoisting();
console.log("\n=== BEST PRACTICES ===");
console.log("Używaj const/let zamiast var");
console.log("Deklaruj zmienne na początku scope");
console.log("Używaj function declarations dla globalnych funkcji");
console.log("Używaj arrow functions dla lokalnych funkcji");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Dlaczego Promise.all() jest szybszy niż sekwencyjne await dla niezależnych operacji?
2. Do czego służą Worker Threads w Node.js?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Zaimplementuj system zdarzeń parku używając callbacków - stwórz funkcje, które przyjmują callbacki dla różnych sytuacji (sukces/błąd).
- Układanie w pionie
Ułóż elementy funkcji async z await: