Kurs JavaScript i TypeScript · Moduł 10: TypeScript w praktyce
Web Workers dla ciężkich obliczeń
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 formularzeDopó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ą:
- Wykonywanie ciężkich obliczeń bez blokowania UI
- Równoległe przetwarzanie dużych zbiorów danych
- Lepszą responsywność aplikacji webowych
- Skalowalność poprzez Worker Pool
- 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. Jaki jest główny problem, który rozwiązują Web Workers?
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:
Zadania po tej lekcji
- PytanieProblemy jednowątkowego JavaScript
- PytanieWeb Worker API
- Zadanie z kodemImplementacja Web Worker
- PytanieOgraniczenia Web Workers
- Kliknij w kolejnościKomunikacja z Web Worker
- Ułóż w kolejnościSkładnia Web Worker
- PytanieShared Workers vs Dedicated Workers
- Kliknij w kolejnościKolejność: Tworzenie Web Workera
- Zadanie z kodemĆwiczenie: SharedArrayBuffer i Atomics
- PytanieOdbieranie danych z Web Workera
- Ułóż w kolejnościCykl życia Web Workera
- Kliknij w kolejnościKolejność: postMessage