Kurs JavaScript i TypeScript · Moduł 10: TypeScript w praktyce

Web Workers dla ciężkich obliczeń

27 min czytania ·
W tej lekcji7

Wyobraź sobie że laboratorium parku sekwencjonuje DNA T-Rexa, a sterownia w tym czasie zamarza: kamery stoją, a przycisk alarmu nie reaguje. Tak zachowuje się przeglądarka, gdy ciężkie obliczenia trafią do głównego wątku. Web Workers to technologia umożliwiająca wykonywanie JavaScript w osobnych wątkach, niezależnie od głównego wątku UI (User Interface), dzięki czemu interfejs pozostaje responsywny.

Czego się nauczysz:

  • przenosić obliczenia do osobnego wątku i rozmawiać z nim przez postMessage
  • rozpoznawać ograniczenia workera i odróżniać Dedicated, Shared i Service Worker
  • budować pulę workerów i współdzielić pamięć przez SharedArrayBuffer
  • mierzyć wydajność i obsługiwać awarie workerów

Dlaczego Web Workers są potrzebne?

Problem jednowątkowej natury JavaScript

Twój kod działa w jednym wątku głównym, który obsługuje też kliknięcia, przewijanie i rysowanie strony. Zobacz, co robi z nim długa pętla:

// Problem: Blokujące obliczenia w głównym wątku
function heavyCalculation(n) {
  console.log('Rozpoczynanie ciężkich obliczeń...');

  // Symulacja intensywnych obliczeń
  let result = 0;
  for (let i = 0; i < n; i++) {
    for (let j = 0; j < 1000000; j++) {
      result += Math.sqrt(i * j);
    }
  }

  console.log('Obliczenia zakończone');
  return result;
}

// To zablokuje UI na kilka sekund!
document.getElementById('calculate-button').addEventListener('click', () => {
  const result = heavyCalculation(5000);
  document.getElementById('result').textContent = result;
});

// Podczas obliczeń użytkownik nie może:
// - Kliknąć innych przycisków
// - Przewijać strony
// - Używać animacji
// - Wpisywać tekst w formularze

Dopóki obliczenia trwają, pętla zdarzeń (event loop) nie obsłuży kliknięcia ani klatki animacji. Ten problem rozwiązują Web Workers.

Porównanie wydajności

Worker nie liczy szybciej, bo to ten sam silnik JavaScript. Różnica polega na tym, kto czeka. Szkic benchmarku porównuje oba podejścia:

// Benchmark: Main Thread vs Web Worker
const performanceTest = {
  // Test bez Web Worker - blokuje UI
  async testMainThread() {
    console.time('Main Thread Calculation');

    const start = performance.now();
    const result = this.calculatePrimes(100000);
    const end = performance.now();

    console.timeEnd('Main Thread Calculation');

    return {
      result: result.length,
      time: end - start,
      blocked: true
    };
  },

  // Test z Web Worker - nie blokuje UI
  async testWebWorker() {
    console.time('Web Worker Calculation');

    const start = performance.now();
    const result = await this.calculatePrimesWorker(100000);
    const end = performance.now();

    console.timeEnd('Web Worker Calculation');

    return {
      result: result.length,
      time: end - start,
      blocked: false
    };
  },

  calculatePrimes(max) {
    const primes = [];
    for (let i = 2; i <= max; i++) {
      if (this.isPrime(i)) {
        primes.push(i);
      }
    }
    return primes;
  },

  isPrime(num) {
    for (let i = 2; i <= Math.sqrt(num); i++) {
      if (num % i === 0) return false;
    }
    return true;
  }
};

Czas bywa podobny, ale z workerem interfejs cały czas reaguje.

Podstawowe implementacje Web Workers

Tworzenie prostego Web Worker

Worker tworzysz konstruktorem new Worker('worker.js'), który uruchamia skrypt w osobnym wątku. Kolejność ma znaczenie: najpierw ustaw nasłuch onmessage, potem wysyłaj dane przez postMessage, a na końcu zakończ pracę metodą terminate():

// main.js - główny wątek
class WebWorkerManager {
  constructor() {
    this.worker = null;
    this.setupWorker();
  }

  setupWorker() {
    // Sprawdzenie wsparcia dla Web Workers
    if (typeof Worker !== 'undefined') {
      this.worker = new Worker('worker.js');

      // Obsługa wiadomości z worker
      this.worker.onmessage = (event) => {
        this.handleWorkerMessage(event.data);
      };

      // Obsługa błędów
      this.worker.onerror = (error) => {
        console.error('Worker error:', error);
      };

      console.log('Web Worker został utworzony');
    } else {
      console.warn('Web Workers nie są wspierane w tej przeglądarce');
    }
  }

  // Wysyłanie zadania do worker
  sendTask(taskType, data) {
    if (this.worker) {
      this.worker.postMessage({
        type: taskType,
        data: data,
        timestamp: Date.now()
      });
    }
  }

  // Obsługa odpowiedzi z worker
  handleWorkerMessage(message) {
    switch (message.type) {
      case 'CALCULATION_COMPLETE':
        this.displayResult(message.result);
        break;
      case 'PROGRESS_UPDATE':
        this.updateProgress(message.progress);
        break;
      case 'ERROR':
        this.handleError(message.error);
        break;
    }
  }

  // Zakończenie pracy worker
  terminateWorker() {
    if (this.worker) {
      this.worker.terminate();
      this.worker = null;
      console.log('Web Worker został zakończony');
    }
  }
}

// Użycie
const workerManager = new WebWorkerManager();

// Wysłanie zadania obliczeń
document.getElementById('start-calculation').addEventListener('click', () => {
  workerManager.sendTask('CALCULATE_PRIMES', { max: 100000 });
});

Odpowiedź czytasz z event.data, przypisując funkcję do onmessage albo przez addEventListener('message', ...). Dane nie są współdzielone: przeglądarka kopiuje je algorytmem structured clone, więc funkcji ani elementów DOM nie wyślesz.

Implementacja worker.js

Po drugiej stronie worker nasłuchuje przez self.onmessage, odpowiada przez self.postMessage i może raportować postęp:

// worker.js - kod wykonywany w osobnym wątku
class WorkerCalculations {
  constructor() {
    this.setupMessageHandler();
  }

  setupMessageHandler() {
    // Główny handler wiadomości z głównego wątku
    self.onmessage = (event) => {
      const { type, data, timestamp } = event.data;

      try {
        this.handleTask(type, data, timestamp);
      } catch (error) {
        this.sendError(error.message);
      }
    };
  }

  handleTask(type, data, timestamp) {
    switch (type) {
      case 'CALCULATE_PRIMES':
        this.calculatePrimes(data.max);
        break;
      case 'PROCESS_IMAGE':
        this.processImage(data.imageData);
        break;
      case 'SORT_LARGE_ARRAY':
        this.sortArray(data.array);
        break;
      case 'MONTE_CARLO_PI':
        this.calculatePiMonteCarlo(data.iterations);
        break;
      default:
        this.sendError(`Unknown task type: ${type}`);
    }
  }

  // Obliczanie liczb pierwszych z raportowaniem postępu
  calculatePrimes(max) {
    const primes = [];
    const updateInterval = Math.floor(max / 100); // Update co 1%

    for (let i = 2; i <= max; i++) {
      if (this.isPrime(i)) {
        primes.push(i);
      }

      // Raportowanie postępu
      if (i % updateInterval === 0) {
        const progress = (i / max) * 100;
        this.sendProgress(progress);
      }
    }

    this.sendResult('CALCULATION_COMPLETE', {
      primes: primes,
      count: primes.length,
      executionTime: performance.now()
    });
  }

  isPrime(num) {
    if (num < 2) return false;
    for (let i = 2; i <= Math.sqrt(num); i++) {
      if (num % i === 0) return false;
    }
    return true;
  }

  // Przetwarzanie obrazu (filtrowanie, transformacje)
  processImage(imageData) {
    const { data, width, height, filterType } = imageData;

    switch (filterType) {
      case 'grayscale':
        this.applyGrayscaleFilter(data);
        break;
      case 'blur':
        this.applyBlurFilter(data, width, height);
        break;
      case 'edge':
        this.applyEdgeDetection(data, width, height);
        break;
    }

    this.sendResult('IMAGE_PROCESSED', {
      processedData: data,
      filterApplied: filterType
    });
  }

  applyGrayscaleFilter(data) {
    for (let i = 0; i < data.length; i += 4) {
      const gray = data[i] * 0.299 + data[i + 1] * 0.587 + data[i + 2] * 0.114;
      data[i] = gray;     // Red
      data[i + 1] = gray; // Green
      data[i + 2] = gray; // Blue
      // Alpha (i + 3) remains unchanged
    }
  }

  // Sortowanie dużych tablic
  sortArray(array) {
    const startTime = performance.now();

    // Implementacja merge sort dla lepszej wydajności
    const sortedArray = this.mergeSort(array);

    const endTime = performance.now();

    this.sendResult('SORT_COMPLETE', {
      sortedArray: sortedArray,
      originalLength: array.length,
      executionTime: endTime - startTime
    });
  }

  mergeSort(arr) {
    if (arr.length <= 1) return arr;

    const mid = Math.floor(arr.length / 2);
    const left = this.mergeSort(arr.slice(0, mid));
    const right = this.mergeSort(arr.slice(mid));

    return this.merge(left, right);
  }

  merge(left, right) {
    const result = [];
    let leftIndex = 0;
    let rightIndex = 0;

    while (leftIndex < left.length && rightIndex < right.length) {
      if (left[leftIndex] <= right[rightIndex]) {
        result.push(left[leftIndex]);
        leftIndex++;
      } else {
        result.push(right[rightIndex]);
        rightIndex++;
      }
    }

    return result.concat(left.slice(leftIndex), right.slice(rightIndex));
  }

  // Obliczanie Pi metodą Monte Carlo
  calculatePiMonteCarlo(iterations) {
    let pointsInCircle = 0;
    const updateInterval = Math.floor(iterations / 100);

    for (let i = 0; i < iterations; i++) {
      const x = Math.random() * 2 - 1; // -1 do 1
      const y = Math.random() * 2 - 1; // -1 do 1

      if (x * x + y * y <= 1) {
        pointsInCircle++;
      }

      if (i % updateInterval === 0) {
        const currentPi = (pointsInCircle / i) * 4;
        const progress = (i / iterations) * 100;

        this.sendProgress(progress, { currentPi, iteration: i });
      }
    }

    const finalPi = (pointsInCircle / iterations) * 4;

    this.sendResult('PI_CALCULATION_COMPLETE', {
      pi: finalPi,
      iterations: iterations,
      accuracy: Math.abs(Math.PI - finalPi)
    });
  }

  // Metody pomocnicze do komunikacji
  sendResult(type, result) {
    self.postMessage({
      type: type,
      result: result,
      timestamp: Date.now()
    });
  }

  sendProgress(progress, additionalData = {}) {
    self.postMessage({
      type: 'PROGRESS_UPDATE',
      progress: progress,
      ...additionalData,
      timestamp: Date.now()
    });
  }

  sendError(errorMessage) {
    self.postMessage({
      type: 'ERROR',
      error: errorMessage,
      timestamp: Date.now()
    });
  }
}

// Inicjalizacja worker
new WorkerCalculations();

Worker ma własny zakres globalny (self) i nie ma dostępu do DOM, document ani window. Może za to używać fetch, XMLHttpRequest, setTimeout, setInterval i IndexedDB. Cykl życia wygląda więc tak: utworzenie, postMessage(), praca w wątku workera i odbiór wyniku w onmessage.

Zaawansowane wzorce Web Workers

Worker Pool dla równoległych obliczeń

Pula (pool) tworzy kilka workerów, zwykle tyle, ile rdzeni podaje navigator.hardwareConcurrency, i rozdziela zadania z kolejki:

// WorkerPool.js - Zarządzanie wieloma worker'ami
class WorkerPool {
  constructor(workerScript, poolSize = navigator.hardwareConcurrency || 4) {
    this.workerScript = workerScript;
    this.poolSize = poolSize;
    this.workers = [];
    this.taskQueue = [];
    this.activeTasksCount = 0;

    this.initializePool();
  }

  initializePool() {
    for (let i = 0; i < this.poolSize; i++) {
      const worker = {
        instance: new Worker(this.workerScript),
        busy: false,
        id: i
      };

      worker.instance.onmessage = (event) => {
        this.handleWorkerMessage(worker, event.data);
      };

      worker.instance.onerror = (error) => {
        this.handleWorkerError(worker, error);
      };

      this.workers.push(worker);
    }

    console.log(`Worker pool initialized with ${this.poolSize} workers`);
  }

  // Wykonanie zadania z wykorzystaniem pool
  execute(taskData) {
    return new Promise((resolve, reject) => {
      const task = {
        data: taskData,
        resolve: resolve,
        reject: reject,
        id: this.generateTaskId()
      };

      const availableWorker = this.getAvailableWorker();

      if (availableWorker) {
        this.assignTaskToWorker(availableWorker, task);
      } else {
        this.taskQueue.push(task);
      }
    });
  }

  getAvailableWorker() {
    return this.workers.find(worker => !worker.busy);
  }

  assignTaskToWorker(worker, task) {
    worker.busy = true;
    worker.currentTask = task;
    this.activeTasksCount++;

    worker.instance.postMessage({
      taskId: task.id,
      ...task.data
    });
  }

  handleWorkerMessage(worker, message) {
    const task = worker.currentTask;

    if (message.type === 'TASK_COMPLETE') {
      task.resolve(message.result);
      this.releaseWorker(worker);
    } else if (message.type === 'TASK_ERROR') {
      task.reject(new Error(message.error));
      this.releaseWorker(worker);
    } else if (message.type === 'PROGRESS_UPDATE') {
      // Przekazanie aktualizacji postępu (opcjonalne)
      if (task.onProgress) {
        task.onProgress(message.progress);
      }
    }
  }

  releaseWorker(worker) {
    worker.busy = false;
    worker.currentTask = null;
    this.activeTasksCount--;

    // Sprawdzenie czy są zadania w kolejce
    if (this.taskQueue.length > 0) {
      const nextTask = this.taskQueue.shift();
      this.assignTaskToWorker(worker, nextTask);
    }
  }

  handleWorkerError(worker, error) {
    console.error(`Worker ${worker.id} error:`, error);

    if (worker.currentTask) {
      worker.currentTask.reject(error);
      this.releaseWorker(worker);
    }
  }

  // Równoległe przetwarzanie dużych zbiorów danych
  async processInParallel(dataArray, chunkProcessor) {
    const chunkSize = Math.ceil(dataArray.length / this.poolSize);
    const chunks = [];

    // Podział danych na chunks
    for (let i = 0; i < dataArray.length; i += chunkSize) {
      chunks.push(dataArray.slice(i, i + chunkSize));
    }

    // Równoległe przetwarzanie chunks
    const promises = chunks.map(chunk =>
      this.execute({
        type: 'PROCESS_CHUNK',
        chunk: chunk,
        processor: chunkProcessor.toString()
      })
    );

    const results = await Promise.all(promises);

    // Połączenie wyników
    return results.flat();
  }

  generateTaskId() {
    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  // Zamknięcie wszystkich worker'ów
  terminate() {
    this.workers.forEach(worker => {
      worker.instance.terminate();
    });

    this.workers = [];
    this.taskQueue = [];
    console.log('Worker pool terminated');
  }

  // Statystyki pool
  getStats() {
    return {
      poolSize: this.poolSize,
      activeWorkers: this.workers.filter(w => w.busy).length,
      queueLength: this.taskQueue.length,
      activeTasks: this.activeTasksCount
    };
  }
}

// Użycie Worker Pool
const workerPool = new WorkerPool('calculation-worker.js', 8);

// Przykład równoległego przetwarzania
async function processLargeDataset() {
  const largeArray = Array.from({ length: 1000000 }, (_, i) => Math.random() * 1000);

  try {
    const results = await workerPool.processInParallel(largeArray, (chunk) => {
      // Funkcja przetwarzania będzie wykonana w worker
      return chunk.map(x => Math.sqrt(x * x + 1));
    });

    console.log('Przetwarzanie zakończone:', results.length);
    console.log('Stats:', workerPool.getStats());
  } catch (error) {
    console.error('Błąd przetwarzania:', error);
  }
}

Gdy wszystkie workery są zajęte, zadanie czeka w kolejce, a releaseWorker od razu podaje następne. chunkProcessor trafia do workera jako tekst, bo postMessage nie przenosi funkcji.

Shared Array Buffer dla wydajnej komunikacji

SharedArrayBuffer to pamięć widoczna dla kilku wątków naraz, więc workery zapisują wyniki mnożenia macierzy prosto do wspólnego bufora, bez kopiowania:

// SharedArrayBufferWorker.js - Współdzielona pamięć między worker'ami
class SharedArrayBufferManager {
  constructor() {
    this.checkSupport();
  }

  checkSupport() {
    if (typeof SharedArrayBuffer === 'undefined') {
      console.warn('SharedArrayBuffer nie jest wspierany');
      this.fallbackToTransferableObjects();
      return false;
    }
    return true;
  }

  // Tworzenie współdzielonej pamięci do obliczeń macierzy
  createSharedMatrixBuffer(rows, cols) {
    const bufferSize = rows * cols * Float64Array.BYTES_PER_ELEMENT;
    const sharedBuffer = new SharedArrayBuffer(bufferSize);
    const matrix = new Float64Array(sharedBuffer);

    return {
      buffer: sharedBuffer,
      matrix: matrix,
      rows: rows,
      cols: cols,

      // Metody pomocnicze (używają zmiennej matrix, bo this w funkcji strzałkowej to menedżer)
      get: (row, col) => {
        return matrix[row * cols + col];
      },

      set: (row, col, value) => {
        matrix[row * cols + col] = value;
      },

      fill: (value) => {
        matrix.fill(value);
      }
    };
  }

  // Równoległe mnożenie macierzy
  async parallelMatrixMultiply(matrixA, matrixB, workerCount = 4) {
    const rowsA = matrixA.rows;
    const colsA = matrixA.cols;
    const colsB = matrixB.cols;

    // Tworzenie współdzielonej macierzy wynikowej
    const resultMatrix = this.createSharedMatrixBuffer(rowsA, colsB);

    // Podział pracy między worker'y
    const rowsPerWorker = Math.ceil(rowsA / workerCount);
    const workers = [];

    for (let i = 0; i < workerCount; i++) {
      const startRow = i * rowsPerWorker;
      const endRow = Math.min(startRow + rowsPerWorker, rowsA);

      if (startRow < rowsA) {
        const worker = new Worker('matrix-worker.js');

        const promise = new Promise((resolve, reject) => {
          worker.onmessage = (event) => {
            if (event.data.type === 'MATRIX_COMPLETE') {
              worker.terminate();
              resolve(event.data.result);
            }
          };

          worker.onerror = reject;
        });

        worker.postMessage({
          type: 'MULTIPLY_MATRIX_ROWS',
          matrixABuffer: matrixA.buffer,
          matrixBBuffer: matrixB.buffer,
          resultBuffer: resultMatrix.buffer,
          dimensions: {
            rowsA: rowsA,
            colsA: colsA,
            colsB: colsB
          },
          rowRange: { start: startRow, end: endRow }
        });

        workers.push(promise);
      }
    }

    await Promise.all(workers);
    return resultMatrix;
  }

  fallbackToTransferableObjects() {
    console.log('Używanie Transferable Objects jako alternatywy');
    // Implementacja z Transferable Objects
  }
}

// matrix-worker.js - Worker do obliczeń macierzy
self.onmessage = function(event) {
  const { type, matrixABuffer, matrixBBuffer, resultBuffer, dimensions, rowRange } = event.data;

  if (type === 'MULTIPLY_MATRIX_ROWS') {
    const matrixA = new Float64Array(matrixABuffer);
    const matrixB = new Float64Array(matrixBBuffer);
    const result = new Float64Array(resultBuffer);

    const { rowsA, colsA, colsB } = dimensions;
    const { start, end } = rowRange;

    // Mnożenie macierzy dla przydzielonych wierszy
    for (let i = start; i < end; i++) {
      for (let j = 0; j < colsB; j++) {
        let sum = 0;
        for (let k = 0; k < colsA; k++) {
          sum += matrixA[i * colsA + k] * matrixB[k * colsB + j];
        }
        result[i * colsB + j] = sum;
      }
    }

    self.postMessage({
      type: 'MATRIX_COMPLETE',
      result: `Rows ${start}-${end} completed`
    });
  }
};

Każdy worker liczy inne wiersze, więc nie wchodzą sobie w drogę. Gdy wątki zmieniają te same komórki, używaj Atomics (na przykład Atomics.add i Atomics.wait), które działają niepodzielnie. Przeglądarki udostępniają SharedArrayBuffer tylko stronom izolowanym nagłówkami Cross-Origin-Opener-Policy: same-origin i Cross-Origin-Embedder-Policy: require-corp.

Service Worker do Background Processing

Poza zwykłym (dedicated) workerem są jeszcze dwa rodzaje. Shared Worker, tworzony przez new SharedWorker(), jest współdzielony przez karty i okna z tego samego źródła (origin). Service Worker stoi między stroną a siecią i obsługuje cache, tryb offline oraz synchronizację w tle:

// ServiceWorkerManager.js - Zarządzanie długotrwałymi zadaniami w tle
class ServiceWorkerManager {
  constructor() {
    this.serviceWorker = null;
    this.messageChannel = null;
    this.setupServiceWorker();
  }

  async setupServiceWorker() {
    if ('serviceWorker' in navigator) {
      try {
        const registration = await navigator.serviceWorker.register('background-worker.js');

        // Oczekiwanie na aktywację service worker
        await navigator.serviceWorker.ready;

        this.serviceWorker = registration.active || registration.waiting || registration.installing;
        this.setupMessageChannel();

        console.log('Service Worker zarejestrowany i gotowy');
      } catch (error) {
        console.error('Błąd rejestracji Service Worker:', error);
      }
    }
  }

  setupMessageChannel() {
    this.messageChannel = new MessageChannel();

    // Obsługa wiadomości od Service Worker
    this.messageChannel.port1.onmessage = (event) => {
      this.handleServiceWorkerMessage(event.data);
    };

    // Wysłanie portu do Service Worker
    navigator.serviceWorker.controller?.postMessage(
      { type: 'INIT_PORT' },
      [this.messageChannel.port2]
    );
  }

  // Zlecenie długotrwałego zadania do Service Worker
  scheduleBackgroundTask(taskConfig) {
    if (this.messageChannel) {
      this.messageChannel.port1.postMessage({
        type: 'SCHEDULE_TASK',
        task: {
          id: this.generateTaskId(),
          ...taskConfig,
          scheduledAt: Date.now()
        }
      });
    }
  }

  // Przykład: Okresowe synchronizowanie danych
  scheduleDataSync(interval = 300000) { // 5 minut
    this.scheduleBackgroundTask({
      type: 'DATA_SYNC',
      interval: interval,
      endpoint: '/api/sync',
      recurring: true
    });
  }

  // Przykład: Przetwarzanie plików w tle
  scheduleFileProcessing(files) {
    files.forEach(file => {
      this.scheduleBackgroundTask({
        type: 'FILE_PROCESSING',
        fileName: file.name,
        fileData: file,
        processor: 'image-compression'
      });
    });
  }

  handleServiceWorkerMessage(message) {
    switch (message.type) {
      case 'TASK_COMPLETED':
        this.onTaskCompleted(message.task, message.result);
        break;
      case 'TASK_FAILED':
        this.onTaskFailed(message.task, message.error);
        break;
      case 'SYNC_COMPLETED':
        this.onSyncCompleted(message.result);
        break;
    }
  }

  onTaskCompleted(task, result) {
    console.log(`Zadanie ${task.id} zakończone:`, result);

    // Aktualizacja UI lub stanu aplikacji
    this.updateApplicationState(task, result);
  }

  generateTaskId() {
    return `bg_task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

// background-worker.js - Service Worker
class BackgroundTaskProcessor {
  constructor() {
    this.activeTasks = new Map();
    this.messagePort = null;
    this.setupEventListeners();
  }

  setupEventListeners() {
    self.addEventListener('message', (event) => {
      if (event.data.type === 'INIT_PORT') {
        this.messagePort = event.ports[0];
        this.setupPortListener();
      }
    });

    // Background Sync
    self.addEventListener('sync', (event) => {
      if (event.tag === 'background-data-sync') {
        event.waitUntil(this.performDataSync());
      }
    });
  }

  setupPortListener() {
    this.messagePort.onmessage = (event) => {
      this.handleTask(event.data);
    };
  }

  async handleTask(message) {
    if (message.type === 'SCHEDULE_TASK') {
      const task = message.task;

      try {
        const result = await this.executeTask(task);

        this.messagePort.postMessage({
          type: 'TASK_COMPLETED',
          task: task,
          result: result
        });
      } catch (error) {
        this.messagePort.postMessage({
          type: 'TASK_FAILED',
          task: task,
          error: error.message
        });
      }
    }
  }

  async executeTask(task) {
    switch (task.type) {
      case 'DATA_SYNC':
        return await this.performDataSync(task);
      case 'FILE_PROCESSING':
        return await this.processFile(task);
      case 'BATCH_CALCULATION':
        return await this.performBatchCalculation(task);
      default:
        throw new Error(`Unknown task type: ${task.type}`);
    }
  }

  async performDataSync(task) {
    try {
      const response = await fetch(task.endpoint, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ timestamp: Date.now() })
      });

      if (!response.ok) {
        throw new Error(`Sync failed: ${response.status}`);
      }

      const data = await response.json();

      // Zapisanie w IndexedDB lub Cache API
      await this.storeDataLocally(data);

      return { success: true, syncedRecords: data.length };
    } catch (error) {
      throw new Error(`Data sync failed: ${error.message}`);
    }
  }

  async processFile(task) {
    // Symulacja przetwarzania pliku
    const { fileName, processor } = task;

    switch (processor) {
      case 'image-compression':
        return await this.compressImage(task.fileData);
      case 'video-transcoding':
        return await this.transcodeVideo(task.fileData);
      default:
        throw new Error(`Unknown processor: ${processor}`);
    }
  }

  async storeDataLocally(data) {
    // Implementacja zapisu w IndexedDB
    return new Promise((resolve, reject) => {
      const request = indexedDB.open('AppDatabase', 1);

      request.onsuccess = (event) => {
        const db = event.target.result;
        const transaction = db.transaction(['syncedData'], 'readwrite');
        const store = transaction.objectStore('syncedData');

        store.put({ id: 'latest', data: data, timestamp: Date.now() });

        transaction.oncomplete = () => resolve();
        transaction.onerror = () => reject(transaction.error);
      };

      request.onerror = () => reject(request.error);
    });
  }
}

new BackgroundTaskProcessor();

Do długich obliczeń Service Worker się nie nadaje, bo przeglądarka usypia go, gdy nie obsługuje zdarzeń. Przy pierwszej wizycie navigator.serviceWorker.controller bywa null, stąd operator ?. w kodzie.

Performance monitoring i debugging

Monitor podmienia postMessage i onmessage, aby zapisać czas każdego zadania:

// WorkerPerformanceMonitor.js
class WorkerPerformanceMonitor {
  constructor() {
    this.metrics = {
      taskExecutionTimes: [],
      memoryUsage: [],
      errorRates: {},
      throughput: []
    };

    this.startTime = performance.now();
  }

  // Monitorowanie wydajności worker'a
  monitorWorkerPerformance(worker, taskId) {
    const startTime = performance.now();
    let memoryBefore = null;

    // Pomiar pamięci (jeśli dostępny)
    if (performance.memory) {
      memoryBefore = performance.memory.usedJSHeapSize;
    }

    const originalPostMessage = worker.postMessage.bind(worker);
    const originalOnMessage = worker.onmessage;

    // Intercept postMessage
    worker.postMessage = (message) => {
      console.log(`[Worker] Sending task ${taskId}:`, message);
      originalPostMessage(message);
    };

    // Intercept onmessage
    worker.onmessage = (event) => {
      const endTime = performance.now();
      const executionTime = endTime - startTime;

      // Zapisanie metryki czasu wykonania
      this.metrics.taskExecutionTimes.push({
        taskId: taskId,
        executionTime: executionTime,
        timestamp: Date.now()
      });

      // Pomiar pamięci po wykonaniu
      if (performance.memory && memoryBefore) {
        const memoryAfter = performance.memory.usedJSHeapSize;
        const memoryDelta = memoryAfter - memoryBefore;

        this.metrics.memoryUsage.push({
          taskId: taskId,
          memoryDelta: memoryDelta,
          timestamp: Date.now()
        });
      }

      console.log(`[Worker] Task ${taskId} completed in ${executionTime.toFixed(2)}ms`);

      if (originalOnMessage) {
        originalOnMessage(event);
      }
    };

    return worker;
  }

  // Analiza wydajności
  generatePerformanceReport() {
    const report = {
      totalRuntime: performance.now() - this.startTime,
      taskCount: this.metrics.taskExecutionTimes.length,
      averageExecutionTime: this.calculateAverageExecutionTime(),
      memoryTrends: this.analyzeMemoryTrends(),
      throughputAnalysis: this.calculateThroughput(),
      recommendations: this.generateRecommendations()
    };

    return report;
  }

  calculateAverageExecutionTime() {
    if (this.metrics.taskExecutionTimes.length === 0) return 0;

    const total = this.metrics.taskExecutionTimes.reduce(
      (sum, metric) => sum + metric.executionTime, 0
    );

    return total / this.metrics.taskExecutionTimes.length;
  }

  analyzeMemoryTrends() {
    if (this.metrics.memoryUsage.length === 0) return null;

    const memoryDeltas = this.metrics.memoryUsage.map(m => m.memoryDelta);
    const averageMemoryDelta = memoryDeltas.reduce((a, b) => a + b, 0) / memoryDeltas.length;

    return {
      averageMemoryDelta: averageMemoryDelta,
      maxMemoryDelta: Math.max(...memoryDeltas),
      minMemoryDelta: Math.min(...memoryDeltas),
      potentialMemoryLeak: averageMemoryDelta > 1024 * 1024 // > 1MB average
    };
  }

  calculateThroughput() {
    const timeWindow = 60000; // 1 minuta
    const now = Date.now();
    const recentTasks = this.metrics.taskExecutionTimes.filter(
      task => now - task.timestamp < timeWindow
    );

    return {
      tasksPerMinute: recentTasks.length,
      averageTaskTime: recentTasks.length > 0
        ? recentTasks.reduce((sum, task) => sum + task.executionTime, 0) / recentTasks.length
        : 0
    };
  }

  generateRecommendations() {
    const recommendations = [];
    const avgTime = this.calculateAverageExecutionTime();
    const memoryTrends = this.analyzeMemoryTrends();

    if (avgTime > 5000) { // > 5 sekund
      recommendations.push('Rozważ podział długotrwałych zadań na mniejsze części');
    }

    if (memoryTrends?.potentialMemoryLeak) {
      recommendations.push('Wykryto potencjalny memory leak - sprawdź zarządzanie pamięcią');
    }

    if (this.metrics.taskExecutionTimes.length > 1000) {
      recommendations.push('Duża liczba zadań - rozważ implementację Worker Pool');
    }

    return recommendations;
  }
}

// Użycie monitoring
const performanceMonitor = new WorkerPerformanceMonitor();

// Monitorowanie konkretnego worker'a
const worker = new Worker('calculation-worker.js');
const monitoredWorker = performanceMonitor.monitorWorkerPerformance(worker, 'task_001');

// Generowanie raportu po pewnym czasie
setTimeout(() => {
  const report = performanceMonitor.generatePerformanceReport();
  console.log('Performance Report:', report);
}, 30000);

performance.memory to niestandardowe API dostępne tylko w Chromium, więc traktuj te pomiary jako orientacyjne.

Best practices i optymalizacje

Optymalna komunikacja z worker'ami

Każda wiadomość to koszt kopiowania, więc małe łączymy w paczki, duże kompresujemy, a bufory przekazujemy bez kopiowania:

// OptimizedWorkerCommunication.js
class OptimizedWorkerCommunication {
  constructor() {
    this.messageQueue = [];
    this.batchSize = 10;
    this.batchTimeout = 16; // ~60fps
    this.compressionThreshold = 1024; // 1KB
  }

  // Batching wiadomości dla lepszej wydajności
  sendBatchedMessage(worker, message) {
    this.messageQueue.push({ worker, message });

    if (this.messageQueue.length >= this.batchSize) {
      this.flushMessageQueue();
    } else {
      // Flush po timeout jeśli batch nie jest pełny
      setTimeout(() => {
        if (this.messageQueue.length > 0) {
          this.flushMessageQueue();
        }
      }, this.batchTimeout);
    }
  }

  flushMessageQueue() {
    const workerMessages = new Map();

    // Grupowanie wiadomości po worker'ach
    this.messageQueue.forEach(({ worker, message }) => {
      if (!workerMessages.has(worker)) {
        workerMessages.set(worker, []);
      }
      workerMessages.get(worker).push(message);
    });

    // Wysyłanie zbatchowanych wiadomości
    workerMessages.forEach((messages, worker) => {
      worker.postMessage({
        type: 'BATCH_MESSAGES',
        messages: messages,
        timestamp: Date.now()
      });
    });

    this.messageQueue = [];
  }

  // Kompresja dużych danych przed wysłaniem
  async sendCompressedData(worker, data) {
    const serializedData = JSON.stringify(data);

    if (serializedData.length > this.compressionThreshold) {
      try {
        // Używanie Compression Streams API (jeśli dostępne)
        const compressedData = await this.compressData(serializedData);

        worker.postMessage({
          type: 'COMPRESSED_DATA',
          data: compressedData,
          compressed: true,
          originalSize: serializedData.length
        });
      } catch (error) {
        // Fallback do niezkompresowanych danych
        worker.postMessage({
          type: 'RAW_DATA',
          data: data,
          compressed: false
        });
      }
    } else {
      worker.postMessage({
        type: 'RAW_DATA',
        data: data,
        compressed: false
      });
    }
  }

  async compressData(data) {
    // Implementacja kompresji (przykład z Compression Streams)
    if ('CompressionStream' in window) {
      const stream = new CompressionStream('gzip');
      const writer = stream.writable.getWriter();
      const reader = stream.readable.getReader();

      writer.write(new TextEncoder().encode(data));
      writer.close();

      const chunks = [];
      let done = false;

      while (!done) {
        const { value, done: readerDone } = await reader.read();
        done = readerDone;
        if (value) {
          chunks.push(value);
        }
      }

      return new Uint8Array(chunks.reduce((acc, chunk) => [...acc, ...chunk], []));
    }

    // Fallback - zwrócenie oryginalnych danych
    return new TextEncoder().encode(data);
  }

  // Transferable Objects dla efektywnego transferu
  sendTransferableData(worker, arrayBuffer) {
    worker.postMessage({
      type: 'TRANSFERABLE_DATA',
      data: arrayBuffer
    }, [arrayBuffer]); // Transfer ownership

    console.log('Transferred ArrayBuffer to worker (zero-copy)');
  }
}

postMessage(data, [arrayBuffer]) przekazuje bufor jako obiekt transferowalny (Transferable): zamiast kopii zmienia się właściciel, a w wątku głównym bufor ma potem długość 0.

Error handling i resilience

Worker może paść przez błąd w skrypcie. Odporny menedżer ponawia zadania z rosnącym opóźnieniem (exponential backoff), pilnuje limitów czasu i odtwarza martwe workery:

// ResilientWorkerManager.js
class ResilientWorkerManager {
  constructor(workerScript, options = {}) {
    this.workerScript = workerScript;
    this.options = {
      maxRetries: 3,
      retryDelay: 1000,
      healthCheckInterval: 30000,
      taskTimeout: 60000,
      ...options
    };

    this.workers = new Map();
    this.failedTasks = new Map();
    this.healthCheckTimer = null;

    this.startHealthChecking();
  }

  // Tworzenie worker'a z error handling
  createResilientWorker(workerId) {
    const worker = new Worker(this.workerScript);
    const workerInfo = {
      instance: worker,
      id: workerId,
      healthy: true,
      taskCount: 0,
      errorCount: 0,
      lastActivity: Date.now(),
      activeTasks: new Map()
    };

    // Error handling
    worker.onerror = (error) => {
      this.handleWorkerError(workerInfo, error);
    };

    // Message handling z timeout
    worker.onmessage = (event) => {
      this.handleWorkerMessage(workerInfo, event.data);
    };

    this.workers.set(workerId, workerInfo);
    return workerInfo;
  }

  // Wykonanie zadania z retry logic
  async executeTaskWithRetry(taskData, workerId = null) {
    let attempts = 0;
    let lastError = null;

    while (attempts < this.options.maxRetries) {
      try {
        const result = await this.executeTask(taskData, workerId);

        // Reset failed task counter po sukcesie
        if (this.failedTasks.has(taskData.id)) {
          this.failedTasks.delete(taskData.id);
        }

        return result;
      } catch (error) {
        attempts++;
        lastError = error;

        console.warn(`Task ${taskData.id} failed (attempt ${attempts}/${this.options.maxRetries}):`, error);

        if (attempts < this.options.maxRetries) {
          // Exponential backoff
          const delay = this.options.retryDelay * Math.pow(2, attempts - 1);
          await this.sleep(delay);

          // Recreate worker jeśli potrzeba
          if (error.type === 'WORKER_DIED') {
            await this.recreateWorker(workerId);
          }
        }
      }
    }

    // Zapisanie zadania jako failed
    this.failedTasks.set(taskData.id, {
      taskData: taskData,
      attempts: attempts,
      lastError: lastError,
      failedAt: Date.now()
    });

    throw new Error(`Task ${taskData.id} failed after ${attempts} attempts: ${lastError.message}`);
  }

  executeTask(taskData, workerId) {
    return new Promise((resolve, reject) => {
      const worker = workerId ? this.workers.get(workerId) : this.getHealthyWorker();

      if (!worker || !worker.healthy) {
        reject(new Error('No healthy worker available'));
        return;
      }

      const taskId = taskData.id || this.generateTaskId();
      const timeoutId = setTimeout(() => {
        worker.activeTasks.delete(taskId);
        reject(new Error(`Task ${taskId} timed out`));
      }, this.options.taskTimeout);

      // Zapisanie zadania jako aktywne
      worker.activeTasks.set(taskId, {
        resolve: resolve,
        reject: reject,
        timeoutId: timeoutId,
        startTime: Date.now()
      });

      worker.taskCount++;
      worker.lastActivity = Date.now();

      worker.instance.postMessage({
        ...taskData,
        taskId: taskId
      });
    });
  }

  handleWorkerMessage(workerInfo, message) {
    const { taskId, type, result, error } = message;

    if (workerInfo.activeTasks.has(taskId)) {
      const task = workerInfo.activeTasks.get(taskId);

      clearTimeout(task.timeoutId);
      workerInfo.activeTasks.delete(taskId);
      workerInfo.lastActivity = Date.now();

      if (type === 'TASK_SUCCESS') {
        task.resolve(result);
      } else if (type === 'TASK_ERROR') {
        workerInfo.errorCount++;
        task.reject(new Error(error));
      }
    }
  }

  handleWorkerError(workerInfo, error) {
    console.error(`Worker ${workerInfo.id} error:`, error);

    workerInfo.healthy = false;
    workerInfo.errorCount++;

    // Odrzucenie wszystkich aktywnych zadań
    workerInfo.activeTasks.forEach(task => {
      clearTimeout(task.timeoutId);
      task.reject(new Error('Worker died'));
    });

    workerInfo.activeTasks.clear();

    // Auto-restart worker
    setTimeout(() => {
      this.recreateWorker(workerInfo.id);
    }, this.options.retryDelay);
  }

  async recreateWorker(workerId) {
    const oldWorker = this.workers.get(workerId);

    if (oldWorker) {
      oldWorker.instance.terminate();
      this.workers.delete(workerId);
    }

    console.log(`Recreating worker ${workerId}`);
    const newWorker = this.createResilientWorker(workerId);

    // Health check dla nowego worker'a
    await this.waitForWorkerReady(newWorker);
  }

  waitForWorkerReady(workerInfo, timeout = 5000) {
    return new Promise((resolve, reject) => {
      const timeoutId = setTimeout(() => {
        reject(new Error(`Worker ${workerInfo.id} failed to initialize`));
      }, timeout);

      // Ping test
      const pingTest = () => {
        workerInfo.instance.postMessage({
          type: 'PING',
          timestamp: Date.now()
        });
      };

      const handlePong = (event) => {
        if (event.data.type === 'PONG') {
          clearTimeout(timeoutId);
          workerInfo.instance.removeEventListener('message', handlePong);
          workerInfo.healthy = true;
          resolve(workerInfo);
        }
      };

      workerInfo.instance.addEventListener('message', handlePong);
      pingTest();
    });
  }

  // Okresowe sprawdzanie zdrowia worker'ów
  startHealthChecking() {
    this.healthCheckTimer = setInterval(() => {
      this.performHealthCheck();
    }, this.options.healthCheckInterval);
  }

  performHealthCheck() {
    this.workers.forEach((workerInfo, workerId) => {
      const timeSinceLastActivity = Date.now() - workerInfo.lastActivity;

      // Sprawdzenie czy worker jest responsywny
      if (timeSinceLastActivity > this.options.healthCheckInterval * 2) {
        console.warn(`Worker ${workerId} appears unresponsive`);
        this.recreateWorker(workerId);
      }

      // Sprawdzenie error rate
      const errorRate = workerInfo.errorCount / Math.max(workerInfo.taskCount, 1);
      if (errorRate > 0.1) { // > 10% error rate
        console.warn(`Worker ${workerId} has high error rate: ${(errorRate * 100).toFixed(2)}%`);
      }
    });
  }

  getHealthyWorker() {
    const healthyWorkers = Array.from(this.workers.values()).filter(w => w.healthy);

    if (healthyWorkers.length === 0) {
      return null;
    }

    // Wybór worker'a z najmniejszą liczbą aktywnych zadań
    return healthyWorkers.reduce((best, current) =>
      current.activeTasks.size < best.activeTasks.size ? current : best
    );
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  generateTaskId() {
    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  // Czyszczenie zasobów
  terminate() {
    if (this.healthCheckTimer) {
      clearInterval(this.healthCheckTimer);
    }

    this.workers.forEach(workerInfo => {
      workerInfo.instance.terminate();
    });

    this.workers.clear();
  }

  // Statystyki systemu
  getSystemStats() {
    const workers = Array.from(this.workers.values());

    return {
      totalWorkers: workers.length,
      healthyWorkers: workers.filter(w => w.healthy).length,
      totalTasks: workers.reduce((sum, w) => sum + w.taskCount, 0),
      activeTasks: workers.reduce((sum, w) => sum + w.activeTasks.size, 0),
      totalErrors: workers.reduce((sum, w) => sum + w.errorCount, 0),
      failedTasksCount: this.failedTasks.size,
      averageErrorRate: workers.length > 0
        ? (workers.reduce((sum, w) => sum + (w.errorCount / Math.max(w.taskCount, 1)), 0) / workers.length * 100).toFixed(2) + '%'
        : '0%'
    };
  }
}

Limit czasu każdego zadania chroni przed zawieszonym workerem, a PING i PONG sprawdzają, czy nowy worker odpowiada.

Praktyczny przykład: renderowanie 3D

Na koniec renderer dzieli ekran na kafelki 64 na 64 piksele i oddaje je puli workerów, które liczą kolory metodą śledzenia promieni (ray tracing):

// 3DRenderingApp.js
class WebWorker3DRenderer {
  constructor(canvasId) {
    this.canvas = document.getElementById(canvasId);
    this.ctx = this.canvas.getContext('2d');
    this.workerPool = new WorkerPool('3d-renderer-worker.js', 4);

    this.scene = {
      objects: [],
      camera: { x: 0, y: 0, z: -10 },
      lights: [{ x: 5, y: 5, z: -5, intensity: 1 }]
    };

    this.setupScene();
  }

  setupScene() {
    // Dodanie obiektów 3D do sceny
    this.scene.objects = [
      { type: 'cube', position: { x: 0, y: 0, z: 0 }, rotation: { x: 0, y: 0, z: 0 } },
      { type: 'sphere', position: { x: 3, y: 0, z: 2 }, radius: 1 },
      { type: 'cylinder', position: { x: -3, y: 0, z: 1 }, height: 2, radius: 0.5 }
    ];
  }

  async render() {
    const startTime = performance.now();

    // Podział ekranu na tiles dla równoległego renderowania
    const tileSize = 64;
    const tilesX = Math.ceil(this.canvas.width / tileSize);
    const tilesY = Math.ceil(this.canvas.height / tileSize);

    const renderPromises = [];

    for (let tileY = 0; tileY < tilesY; tileY++) {
      for (let tileX = 0; tileX < tilesX; tileX++) {
        const tileData = {
          type: 'RENDER_TILE',
          tile: {
            x: tileX * tileSize,
            y: tileY * tileSize,
            width: Math.min(tileSize, this.canvas.width - tileX * tileSize),
            height: Math.min(tileSize, this.canvas.height - tileY * tileSize)
          },
          scene: this.scene,
          screenDimensions: {
            width: this.canvas.width,
            height: this.canvas.height
          }
        };

        renderPromises.push(
          this.workerPool.execute(tileData).then(result => ({
            ...result,
            tileX: tileX,
            tileY: tileY
          }))
        );
      }
    }

    // Oczekiwanie na wszystkie tiles
    const renderedTiles = await Promise.all(renderPromises);

    // Składanie tiles na canvas
    renderedTiles.forEach(tile => {
      const imageData = new ImageData(
        new Uint8ClampedArray(tile.pixelData),
        tile.width,
        tile.height
      );

      this.ctx.putImageData(imageData, tile.x, tile.y);
    });

    const renderTime = performance.now() - startTime;
    console.log(`Frame rendered in ${renderTime.toFixed(2)}ms`);
  }

  // Animacja sceny
  animate() {
    this.scene.objects.forEach(obj => {
      if (obj.rotation) {
        obj.rotation.y += 0.02;
        obj.rotation.x += 0.01;
      }
    });

    this.render().then(() => {
      requestAnimationFrame(() => this.animate());
    });
  }
}

// 3d-renderer-worker.js
class Tile3DRenderer {
  constructor() {
    self.onmessage = (event) => {
      this.handleRenderTask(event.data);
    };
  }

  handleRenderTask(data) {
    if (data.type === 'RENDER_TILE') {
      const result = this.renderTile(data.tile, data.scene, data.screenDimensions);

      self.postMessage({
        type: 'TASK_COMPLETE',
        result: result
      });
    }
  }

  renderTile(tile, scene, screenDimensions) {
    const { x, y, width, height } = tile;
    const pixelData = new Uint8ClampedArray(width * height * 4);

    for (let py = 0; py < height; py++) {
      for (let px = 0; px < width; px++) {
        const screenX = x + px;
        const screenY = y + py;

        // Przekształcenie współrzędnych ekranu na ray
        const ray = this.screenToRay(screenX, screenY, screenDimensions, scene.camera);

        // Ray tracing
        const color = this.traceRay(ray, scene);

        const pixelIndex = (py * width + px) * 4;
        pixelData[pixelIndex] = color.r;     // Red
        pixelData[pixelIndex + 1] = color.g; // Green
        pixelData[pixelIndex + 2] = color.b; // Blue
        pixelData[pixelIndex + 3] = 255;     // Alpha
      }
    }

    return {
      x: x,
      y: y,
      width: width,
      height: height,
      pixelData: Array.from(pixelData)
    };
  }

  screenToRay(screenX, screenY, screenDimensions, camera) {
    const normalizedX = (screenX / screenDimensions.width) * 2 - 1;
    const normalizedY = 1 - (screenY / screenDimensions.height) * 2;

    return {
      origin: camera,
      direction: {
        x: normalizedX,
        y: normalizedY,
        z: 1
      }
    };
  }

  traceRay(ray, scene) {
    let closestDistance = Infinity;
    let hitColor = { r: 0, g: 0, b: 50 }; // Tło

    // Sprawdzanie kolizji z obiektami
    scene.objects.forEach(obj => {
      const distance = this.rayObjectIntersection(ray, obj);

      if (distance > 0 && distance < closestDistance) {
        closestDistance = distance;
        hitColor = this.calculateObjectColor(obj, ray, distance, scene.lights);
      }
    });

    return hitColor;
  }

  rayObjectIntersection(ray, obj) {
    switch (obj.type) {
      case 'sphere':
        return this.raySphereIntersection(ray, obj);
      case 'cube':
        return this.rayCubeIntersection(ray, obj);
      default:
        return -1;
    }
  }

  raySphereIntersection(ray, sphere) {
    const dx = ray.origin.x - sphere.position.x;
    const dy = ray.origin.y - sphere.position.y;
    const dz = ray.origin.z - sphere.position.z;

    const a = ray.direction.x * ray.direction.x +
              ray.direction.y * ray.direction.y +
              ray.direction.z * ray.direction.z;

    const b = 2 * (dx * ray.direction.x + dy * ray.direction.y + dz * ray.direction.z);
    const c = dx * dx + dy * dy + dz * dz - sphere.radius * sphere.radius;

    const discriminant = b * b - 4 * a * c;

    if (discriminant < 0) return -1;

    const t1 = (-b - Math.sqrt(discriminant)) / (2 * a);
    const t2 = (-b + Math.sqrt(discriminant)) / (2 * a);

    return t1 > 0 ? t1 : (t2 > 0 ? t2 : -1);
  }

  calculateObjectColor(obj, ray, distance, lights) {
    // Uproszczone oświetlenie
    const baseColor = obj.type === 'sphere'
      ? { r: 255, g: 100, b: 100 }
      : { r: 100, g: 255, b: 100 };

    // Symulacja oświetlenia
    const lightIntensity = 0.7 + 0.3 * Math.sin(distance * 0.1);

    return {
      r: Math.floor(baseColor.r * lightIntensity),
      g: Math.floor(baseColor.g * lightIntensity),
      b: Math.floor(baseColor.b * lightIntensity)
    };
  }
}

new Tile3DRenderer();

Wątek główny tylko składa kafelki na canvasie. Szybciej byłoby przekazywać bufory pikseli jako Transferable zamiast zamieniać je na tablice przez Array.from.

Podsumowanie

Web Workers umożliwiają:

  1. Wykonywanie ciężkich obliczeń bez blokowania UI
  2. Równoległe przetwarzanie dużych zbiorów danych
  3. Lepszą responsywność aplikacji webowych
  4. Skalowalność poprzez Worker Pool
  5. Background processing z Service Workers

Sięgniesz po nie przy obliczeniach matematycznych i naukowych, przetwarzaniu obrazów i wideo, renderowaniu 3D, sortowaniu i filtrowaniu dużych zbiorów danych, kompresji, kryptografii i haszowaniu oraz uruchamianiu modeli uczenia maszynowego. Zacznij od jednego workera w trybie modułu (new Worker('worker.js', { type: 'module' })), a pulę buduj dopiero, gdy pomiary pokażą, że to za mało. W edytorze poniżej czeka symulacja workera, a w kolejnej lekcji zajrzymy do pamięci i garbage collectora.

Pamiętaj: worker to osobne laboratorium za szybą, które pracuje równolegle, ale rozmawiasz z nim tylko przez okienko postMessage.

Kod do tej lekcji: index.js
// Web Workers - przykład obliczania liczb pierwszych
// Główny wątek
console.log("Park Jurajski - System Analityczny DNA");
console.log("Rozpoczynanie ciężkich obliczeń bez blokowania UI\n");

// Symulacja Web Worker (prawdziwy worker wymaga osobnego pliku)
function simulateWorker() {
  // Funkcja sprawdzająca czy liczba jest pierwsza
  function isPrime(n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 === 0 || n % 3 === 0) return false;

    for (let i = 5; i * i <= n; i += 6) {
      if (n % i === 0 || n % (i + 2) === 0) return false;
    }
    return true;
  }

  // Znajdź liczby pierwsze w zakresie
  function findPrimes(start, end) {
    const primes = [];
    for (let i = start; i <= end; i++) {
      if (isPrime(i)) {
        primes.push(i);
      }
    }
    return primes;
  }

  return findPrimes;
}

// Główna funkcja
async function calculatePrimesInBackground() {
  console.log("Rozpoczynam obliczenia w tle...");
  console.log("UI pozostaje responsywne!\n");

  const findPrimes = simulateWorker();

  // Symulacja długotrwałych obliczeń
  const start = 1;
  const end = 10000;

  console.time("Czas obliczeń");
  const primes = findPrimes(start, end);
  console.timeEnd("Czas obliczeń");

  console.log(`\nZnaleziono ${primes.length} liczb pierwszych`);
  console.log(`Pierwsze 20: ${primes.slice(0, 20).join(', ')}`);
  console.log(`Ostatnie 20: ${primes.slice(-20).join(', ')}`);
}

// Worker API structure (dla referencji)
console.log("=== Struktura Web Worker API ===");
console.log("1. Tworzenie workera:");
console.log("   const worker = new Worker('worker.js');");
console.log("\n2. Wysyłanie danych do workera:");
console.log("   worker.postMessage({ action: 'calculate', data: 100 });");
console.log("\n3. Odbieranie wyników:");
console.log("   worker.onmessage = (event) => console.log(event.data);");
console.log("\n4. Obsługa błędów:");
console.log("   worker.onerror = (error) => console.error(error);");
console.log("\n5. Zamykanie workera:");
console.log("   worker.terminate();\n");

// Uruchom obliczenia
calculatePrimesInBackground();

// Demonstracja równoczesnego działania UI
console.log("\nUI działa normalnie podczas obliczeń!");
console.log("Można wykonywać inne operacje...");
console.log("Kliknięcia, animacje, wszystko jest responsywne!");

// Przykład "workera" z promise
class PrimeWorkerSimulator {
  calculate(start, end) {
    return new Promise((resolve) => {
      setTimeout(() => {
        const primes = [];
        for (let i = start; i <= end; i++) {
          if (this.isPrime(i)) primes.push(i);
        }
        resolve(primes);
      }, 0); // Async execution
    });
  }

  isPrime(n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 === 0 || n % 3 === 0) return false;

    for (let i = 5; i * i <= n; i += 6) {
      if (n % i === 0 || n % (i + 2) === 0) return false;
    }
    return true;
  }
}

// Test z promise-based worker
const workerSim = new PrimeWorkerSimulator();
workerSim.calculate(10000, 11000).then(primes => {
  console.log(`\nObliczenia zakończone! Znaleziono ${primes.length} liczb pierwszych między 10000 a 11000`);
});

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 jest główny problem, który rozwiązują Web Workers?

  2. 2. Jaką metodę używamy do wysłania danych do Web Workera?

To 2 z 5 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz worker do obliczania liczb pierwszych.

  • Klikanie w kolejności

    Uporządkuj kroki komunikacji z Web Worker.

  • Układanie w poziomie

    Ułóż elementy tworzenia Web Workera:

  • Klikanie w kolejności

    Ułóż elementy tworzenia Web Workera w odpowiedniej kolejności:

  • Edytor kodu

    Użyj SharedArrayBuffer do komunikacji między wątkami.

  • Układanie w pionie

    Ułóż etapy cyklu życia Web Workera w odpowiedniej kolejności:

  • Klikanie w kolejności

    Ułóż elementy wysyłania wiadomości do Workera:

  1. PytanieProblemy jednowątkowego JavaScript
  2. PytanieWeb Worker API
  3. Zadanie z kodemImplementacja Web Worker
  4. PytanieOgraniczenia Web Workers
  5. Kliknij w kolejnościKomunikacja z Web Worker
  6. Ułóż w kolejnościSkładnia Web Worker
  7. PytanieShared Workers vs Dedicated Workers
  8. Kliknij w kolejnościKolejność: Tworzenie Web Workera
  9. Zadanie z kodemĆwiczenie: SharedArrayBuffer i Atomics
  10. PytanieOdbieranie danych z Web Workera
  11. Ułóż w kolejnościCykl życia Web Workera
  12. Kliknij w kolejnościKolejność: postMessage

Przydatne artykuły