Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne

Równoległe wykonywanie zadań asynchronicznych

16 min czytania ·
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:

  1. Promise.all() - podstawowe narzędzie do równoległego wykonywania wielu zadań asynchronicznych
  2. Kontrolowanie liczby równoległych operacji - techniki ograniczania maksymalnej równoległości
  3. Przetwarzanie wsadowe - przetwarzanie danych w partiach
  4. Kolejkowanie zadań z priorytetami - wykonywanie ważniejszych zadań w pierwszej kolejności
  5. Przetwarzanie strumieniowe - przetwarzanie danych w miarę ich napływania
  6. Worker Threads i Web Workers - wykonywanie zadań w oddzielnych wątkach
  7. 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. 1. Dlaczego Promise.all() jest szybszy niż sekwencyjne await dla niezależnych operacji?

  2. 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:

  1. PytaniePromise.all a równoległość
  2. PytanieWorker Threads w Node.js
  3. PytanieObsługa błędów w Promise.all
  4. Zadanie z kodemPraktyka: Callbacki asynchroniczne
  5. Ułóż w kolejnościKolejność elementów async/await

Przydatne artykuły