Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React

Web Workers w React

6 min czytania ·
W tej lekcji6

Wyobraź sobie że główny komputer pokładowy Twojego statku (main thread) musi jednocześnie renderować kokpit, obsługiwać systemy nawigacyjne i przeliczać trajektorię lotu. Jeśli obliczenia trajektorii są zbyt ciężkie, kokpit zamarza i kapitan nie może kliknąć żadnego przycisku. Rozwiązanie? Dedykowany komputer obliczeniowy, czyli Web Worker, który pracuje równolegle i nie blokuje głównego systemu.

Czym są Web Workers?

Web Workers to mechanizm przeglądarki, który uruchamia kod JavaScript w osobnym wątku. Główny wątek odpowiada za renderowanie UI, obsługę zdarzeń i interakcję z użytkownikiem, więc ciężkie obliczenia na nim zamrażają interfejs. Tak wygląda problem:

// BEZ Web Worker - blokuje main thread
function HeavyCalculation() {
  const [result, setResult] = useState(null);

  const calculate = () => {
    // To zablokuje UI na kilka sekund!
    let sum = 0;
    for (let i = 0; i < 1_000_000_000; i++) {
      sum += Math.sqrt(i);
    }
    setResult(sum);
  };

  return (
    <div>
      <button onClick={calculate}>Oblicz</button>
      <p>Wynik: {result}</p>
    </div>
  );
}

Pętla z miliardem iteracji zajmie główny wątek na kilka sekund: przycisk nie zareaguje, a React nie wyrenderuje nawet stanu ładowania. useState niczego tu nie ratuje, bo problemem jest zajęty wątek, a nie sposób przechowywania wyniku.

Tworzenie Web Workera

Worker to osobny plik JavaScript z własnym zakresem globalnym self. Z głównym wątkiem rozmawia wyłącznie przez wiadomości: postMessage wysyła, a onmessage odbiera:

// worker.js - plik Workera (oddzielny wątek)
self.onmessage = function(event) {
  const { type, data } = event.data;

  if (type === 'CALCULATE_TRAJECTORY') {
    const result = calculateTrajectory(data);
    self.postMessage({ type: 'RESULT', result });
  }
};

function calculateTrajectory(params) {
  let trajectory = [];
  for (let t = 0; t < params.steps; t++) {
    const x = params.speed * t * Math.cos(params.angle);
    const y = params.speed * t * Math.sin(params.angle) - 0.5 * 9.81 * t * t;
    trajectory.push({ x, y, t });
  }
  return trajectory;
}

Worker czeka na wiadomość typu CALCULATE_TRAJECTORY, liczy i odsyła wynik przez self.postMessage. Nie ma dostępu do DOM ani do stanu Reacta, zna tylko to, co przyszło w event.data.

Po stronie Reacta tworzysz workera raz, w efekcie, i trzymasz go w useRef:

// App.jsx - komponent React (główny wątek)
import { useState, useRef, useEffect } from 'react';

function TrajectoryCalculator() {
  const [result, setResult] = useState(null);
  const [isCalculating, setIsCalculating] = useState(false);
  const workerRef = useRef(null);

  useEffect(() => {
    workerRef.current = new Worker(new URL('./worker.js', import.meta.url));

    workerRef.current.onmessage = (event) => {
      if (event.data.type === 'RESULT') {
        setResult(event.data.result);
        setIsCalculating(false);
      }
    };

    return () => workerRef.current?.terminate();
  }, []);

  const handleCalculate = () => {
    setIsCalculating(true);
    workerRef.current.postMessage({
      type: 'CALCULATE_TRAJECTORY',
      data: { speed: 1000, angle: 0.785, steps: 100000 }
    });
  };

  return (
    <div>
      <button onClick={handleCalculate} disabled={isCalculating}>
        {isCalculating ? 'Obliczam...' : 'Oblicz trajektorię'}
      </button>
      {result && <p>Punktów trajektorii: {result.length}</p>}
    </div>
  );
}

Zapis new Worker(new URL('./worker.js', import.meta.url)) rozpoznają bundlery, jak webpack 5 i Vite, i same dołączają plik workera. Cleanup wywołuje terminate(), więc po odmontowaniu komponentu wątek nie pracuje dalej. Dane z postMessage są kopiowane algorytmem structured clone, dlatego funkcji ani elementów DOM nie wyślesz.

Własny hook: useWorker

Żeby nie powtarzać tej logiki w każdym komponencie, zamknij ją w hooku wielokrotnego użytku:

import { useState, useRef, useEffect, useCallback } from 'react';

function useWorker(workerFactory) {
  const [result, setResult] = useState(null);
  const [error, setError] = useState(null);
  const [isRunning, setIsRunning] = useState(false);
  const workerRef = useRef(null);

  useEffect(() => {
    workerRef.current = workerFactory();

    workerRef.current.onmessage = (event) => {
      setResult(event.data);
      setIsRunning(false);
    };

    workerRef.current.onerror = (err) => {
      setError(err.message);
      setIsRunning(false);
    };

    return () => workerRef.current?.terminate();
  }, []);

  const run = useCallback((data) => {
    setIsRunning(true);
    setError(null);
    workerRef.current?.postMessage(data);
  }, []);

  return { result, error, isRunning, run };
}

run wysyła dane, a hook sam zarządza stanami result, error i isRunning. Przekazujesz fabrykę, np. () => new Worker(url), bo worker ma powstać w efekcie, a nie przy każdym renderze.

Ręczne rozpakowywanie wiadomości szybko męczy. Biblioteka Comlink od Google Chrome Labs pozwala traktować workera jak obiekt z asynchronicznymi metodami. W pliku workera wystawiasz obiekt przez Comlink.expose:

// worker.js z Comlink
import * as Comlink from 'comlink';

const navigationComputer = {
  async calculateRoute(origin, destination) {
    const route = computeOptimalPath(origin, destination);
    return route;
  },
  async analyzeStarField(stars) {
    return stars.map(star => ({
      ...star,
      habitableZone: calculateHabitableZone(star.mass, star.luminosity)
    }));
  }
};

Comlink.expose(navigationComputer);

Metody calculateRoute i analyzeStarField nadal działają w osobnym wątku, zmienia się tylko sposób ich wywołania.

W komponencie owijasz workera przez Comlink.wrap i wołasz metody jak zwykłe funkcje asynchroniczne:

// App.jsx z Comlink
import * as Comlink from 'comlink';

function NavigationPanel() {
  const [route, setRoute] = useState(null);
  const navComputer = useRef(null);

  useEffect(() => {
    const worker = new Worker(new URL('./worker.js', import.meta.url), { type: 'module' });
    navComputer.current = Comlink.wrap(worker);
    return () => worker.terminate();
  }, []);

  const planRoute = async () => {
    // Wywołujemy metodę jak zwykłą funkcję async!
    const result = await navComputer.current.calculateRoute(
      { x: 0, y: 0, z: 0 },
      { x: 4.2, y: 1.3, z: 0.7 }
    );
    setRoute(result);
  };

  return (
    <div>
      <button onClick={planRoute}>Planuj trasę</button>
      {route && <RouteVisualization data={route} />}
    </div>
  );
}

Pod spodem Comlink dalej wysyła postMessage, a każde wywołanie zwraca obietnicę, dlatego potrzebny jest await. Ten plik workera używa instrukcji import, więc new Worker dostaje opcję { type: 'module' } i przeglądarka uruchamia go jako worker modułowy. Na tym opiera się też tryb deweloperski Vite, a przy budowaniu bundler dołącza zależności do pliku workera.

Kiedy używać Web Workers w React?

Workery są idealne do ciężkich obliczeń matematycznych, jak symulacje i analiza danych, oraz do parsowania dużych zbiorów, na przykład pliku CSV z 500 000 wierszy albo JSON-a z tysiącami rekordów. Sprawdzą się też przy przetwarzaniu obrazów (filtry, kompresja) i wyszukiwaniu rozmytym w dużych kolekcjach.

Nie potrzebujesz ich do prostych operacji na stanie ani do zapytań API przez fetch czy axios, bo oczekiwanie na sieć nie blokuje wątku. Nie pomogą też przy manipulacji DOM, bo workery nie mają do niego dostępu. Polecam najpierw zmierzyć w zakładce Performance, czy zadanie trwa dłużej niż 50 ms, bo od tej granicy przeglądarka uznaje je za długie, i dopiero wtedy przenieść je do workera, najlepiej przez Comlink.

Podsumowanie

  1. Web Workers - osobny wątek dla ciężkich obliczeń
  2. Komunikacja - postMessage / onmessage
  3. Własny hook useWorker - enkapsulacja logiki workera
  4. Comlink - uproszczone API (metody async zamiast wiadomości)
  5. Ograniczenia - brak dostępu do DOM, osobny zakres globalny

W kolejnej lekcji React Compiler zajmie się wydajnością od drugiej strony: zamiast przenosić pracę do innego wątku, pominie zbędne rendery.

Pamiętaj: Web Worker to drugi komputer pokładowy - liczy trajektorię w tle, a kokpit przez cały czas słucha kapitana.

Kod do tej lekcji: App.jsx
import React, { useState, useRef, useEffect, useCallback } from 'react';

// === WEB WORKERS W REACT ===
// Symulacja ciężkich obliczeń w oddzielnym wątku

// Własny hook useWorker - logika Workera w jednym miejscu
function useWorker() {
  const [result, setResult] = useState(null);
  const [isRunning, setIsRunning] = useState(false);
  const [progress, setProgress] = useState(0);

  // Symulacja Workera (ten podgląd nie ma osobnego pliku workera)
  const run = useCallback((params) => {
    setIsRunning(true);
    setProgress(0);
    setResult(null);

    // Obliczenia w porcjach z setTimeout udają "oddzielny wątek"
    const totalSteps = params.steps || 10;
    let currentStep = 0;
    const trajectory = [];

    const step = () => {
      for (let i = 0; i < 1000; i++) {
        const t = currentStep * 0.01;
        const x = params.speed * t * Math.cos(params.angle);
        const y = params.speed * t * Math.sin(params.angle) - 0.5 * 9.81 * t * t;
        trajectory.push({ x: +x.toFixed(2), y: +y.toFixed(2), t: +t.toFixed(3) });
        currentStep++;
      }
      setProgress(Math.min(100, Math.round((currentStep / (totalSteps * 1000)) * 100)));

      if (currentStep < totalSteps * 1000) {
        setTimeout(step, 0); // Oddaj sterowanie głównemu wątkowi
      } else {
        setResult(trajectory);
        setIsRunning(false);
      }
    };
    setTimeout(step, 0);
  }, []);

  return { result, isRunning, progress, run };
}

// Panel trajektorii - wizualizacja
function TrajectoryPanel({ trajectory }) {
  if (!trajectory || trajectory.length === 0) return null;

  const maxX = Math.max(...trajectory.map(p => Math.abs(p.x)));
  const maxY = Math.max(...trajectory.map(p => Math.abs(p.y)));
  const scale = Math.max(maxX, maxY) || 1;

  const validPoints = trajectory.filter(p => p.y >= 0).slice(0, 200);

  return (
    <div style={styles.trajectoryPanel}>
      <h3 style={styles.sectionTitle}>Trajektoria lotu</h3>
      <div style={styles.canvas}>
        {validPoints.map((p, i) => (
          <div
            key={i}
            style={{
              position: 'absolute',
              left: (p.x / scale * 45 + 50) + '%',
              bottom: (p.y / scale * 80 + 5) + '%',
              width: '3px', height: '3px',
              borderRadius: '50%',
              background: `hsl(${180 + (i / validPoints.length) * 60}, 100%, 60%)`,
            }}
          />
        ))}
      </div>
      <p style={styles.stats}>
        Punktów: {trajectory.length} | Max X: {maxX.toFixed(0)}m | Max Y: {Math.max(...trajectory.map(p => p.y)).toFixed(0)}m
      </p>
    </div>
  );
}

// Panel kontrolny - interaktywny (UI reaguje podczas obliczeń)
function ControlPanel({ isRunning }) {
  const [clicks, setClicks] = useState(0);

  return (
    <div style={styles.controlPanel}>
      <h3 style={styles.sectionTitle}>Panel kontrolny (główny wątek)</h3>
      <p style={styles.hint}>
        {isRunning
          ? 'Worker oblicza... ale UI nadal działa!'
          : 'Klikaj przycisk podczas obliczeń - UI nie zamarza'}
      </p>
      <button onClick={() => setClicks(c => c + 1)} style={styles.clickBtn}>
        Kliknięcia: {clicks}
      </button>
      <div style={{ ...styles.indicator, background: isRunning ? '#ffaa00' : '#00ff88' }}>
        {isRunning ? 'WORKER AKTYWNY' : 'WORKER WOLNY'}
      </div>
    </div>
  );
}

function App() {
  const { result, isRunning, progress, run } = useWorker();
  const [speed, setSpeed] = useState(500);
  const [angle, setAngle] = useState(45);
  const [steps, setSteps] = useState(5);

  const handleLaunch = () => {
    run({
      speed,
      angle: (angle * Math.PI) / 180,
      steps,
    });
  };

  return (
    <div style={styles.container}>
      <header style={styles.header}>
        <h1 style={styles.title}>Web Workers - Obliczenia trajektorii</h1>
        <p style={styles.subtitle}>Ciężkie obliczenia bez blokowania UI</p>
      </header>

      <div style={styles.grid}>
        <div style={styles.inputPanel}>
          <h3 style={styles.sectionTitle}>Parametry lotu</h3>
          <label style={styles.label}>
            Prędkość: {speed} m/s
            <input type="range" min="100" max="2000" value={speed}
              onChange={e => setSpeed(+e.target.value)} style={styles.slider} />
          </label>
          <label style={styles.label}>
            Kąt: {angle}°
            <input type="range" min="10" max="80" value={angle}
              onChange={e => setAngle(+e.target.value)} style={styles.slider} />
          </label>
          <label style={styles.label}>
            Złożoność: {steps} tys. kroków
            <input type="range" min="1" max="20" value={steps}
              onChange={e => setSteps(+e.target.value)} style={styles.slider} />
          </label>

          <button onClick={handleLaunch} disabled={isRunning} style={styles.launchBtn}>
            {isRunning ? 'Obliczam...' : 'Oblicz trajektorię'}
          </button>

          {isRunning && (
            <div style={styles.progressBar}>
              <div style={{ ...styles.progressFill, width: progress + '%' }} />
              <span style={styles.progressText}>{progress}%</span>
            </div>
          )}
        </div>

        <ControlPanel isRunning={isRunning} />
      </div>

      <TrajectoryPanel trajectory={result} />

      <div style={styles.info}>
        <h3 style={{ color: '#ffd700', fontSize: '13px', margin: '0 0 8px' }}>Jak to działa:</h3>
        <ul style={{ margin: 0, paddingLeft: '20px', fontSize: '12px', color: '#8892b0' }}>
          <li>Obliczenia trajektorii odbywają się w "tle" (symulacja Web Workera)</li>
          <li>Panel kontrolny reaguje na kliknięcia PODCZAS obliczeń</li>
          <li>W prawdziwej aplikacji new Worker() tworzy oddzielny wątek</li>
          <li>Komunikacja: postMessage() / onmessage</li>
        </ul>
      </div>
    </div>
  );
}

const styles = {
  container: { fontFamily: 'system-ui', background: '#0a0e17', color: '#e0e1dd', minHeight: '100vh', padding: '16px' },
  header: { textAlign: 'center', marginBottom: '16px' },
  title: { fontSize: '20px', color: '#00d4ff', margin: '0 0 4px' },
  subtitle: { fontSize: '12px', color: '#8892b0', margin: 0 },
  grid: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '12px', marginBottom: '12px' },
  inputPanel: { background: 'rgba(0,212,255,0.05)', borderRadius: '8px', padding: '14px', border: '1px solid rgba(0,212,255,0.15)' },
  controlPanel: { background: 'rgba(0,212,255,0.05)', borderRadius: '8px', padding: '14px', border: '1px solid rgba(0,212,255,0.15)' },
  sectionTitle: { fontSize: '14px', color: '#00d4ff', margin: '0 0 10px' },
  label: { display: 'block', fontSize: '12px', color: '#8892b0', marginBottom: '10px' },
  slider: { width: '100%', marginTop: '4px' },
  launchBtn: { width: '100%', padding: '10px', background: 'linear-gradient(135deg, #00d4ff, #0088cc)', color: '#0a0e17', border: 'none', borderRadius: '6px', cursor: 'pointer', fontWeight: 'bold', fontSize: '13px' },
  progressBar: { marginTop: '8px', height: '20px', background: '#1a2a3c', borderRadius: '10px', position: 'relative', overflow: 'hidden' },
  progressFill: { height: '100%', background: 'linear-gradient(90deg, #00d4ff, #00ff88)', borderRadius: '10px', transition: 'width 0.3s' },
  progressText: { position: 'absolute', top: '50%', left: '50%', transform: 'translate(-50%, -50%)', fontSize: '11px', fontWeight: 'bold', color: '#0a0e17' },
  hint: { fontSize: '12px', color: '#8892b0', marginBottom: '10px' },
  clickBtn: { width: '100%', padding: '12px', background: '#1a3a5c', color: '#00d4ff', border: '1px solid rgba(0,212,255,0.3)', borderRadius: '6px', cursor: 'pointer', fontSize: '16px', fontWeight: 'bold', marginBottom: '10px' },
  indicator: { textAlign: 'center', padding: '6px', borderRadius: '4px', fontSize: '11px', fontWeight: 'bold', color: '#0a0e17' },
  trajectoryPanel: { background: 'rgba(0,212,255,0.05)', borderRadius: '8px', padding: '14px', border: '1px solid rgba(0,212,255,0.15)', marginBottom: '12px' },
  canvas: { position: 'relative', height: '200px', background: 'rgba(0,0,0,0.4)', borderRadius: '6px', overflow: 'hidden' },
  stats: { fontSize: '12px', color: '#8892b0', marginTop: '8px', textAlign: 'center' },
  info: { padding: '12px', background: 'rgba(255,215,0,0.05)', border: '1px solid rgba(255,215,0,0.15)', borderRadius: '8px' },
};

export default App;

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. Jaki mechanizm służy do komunikacji między głównym wątkiem a Web Workerem?

  2. 2. Które zadanie jest IDEALNYM kandydatem do przeniesienia do Web Workera?

  1. PytanieWeb Workers - komunikacja
  2. PytanieZastosowania Web Workers

Przydatne artykuły