Worker.terminate() — Methode · JavaScript-Referenz

Signatur

Worker.prototype.terminate()

Beschreibung

Die Methode terminate() der Worker-Schnittstelle bricht den zugehörigen Worker-Thread sofort ab. Laufender Code im Worker wird unterbrochen, noch nicht verarbeitete Nachrichten in der Warteschlange werden verworfen, und der Worker kann danach keine Nachrichten mehr senden oder empfangen.

Einsatzgebiete sind vor allem: das Abbrechen langer Berechnungen (z. B. wenn der Nutzer eine Aktion abbricht), Zeitlimits für aufwendige Aufgaben und das Freigeben von Speicher und CPU, wenn ein Worker nicht mehr gebraucht wird – etwa beim Verlassen einer Ansicht in einer Single-Page-App.

Anders als self.close(), das der Worker selbst aufruft, wird terminate() vom Hauptthread (bzw. vom erzeugenden Kontext) aus aufgerufen. Der Worker bekommt dabei kein Ereignis und keine Gelegenheit zum Aufräumen – finally-Blöcke oder ausstehende Promises im Worker werden nicht mehr ausgeführt.

Rückgabewert

Typ

void

Beschreibung

Gibt undefined zurück.

Beispiele

Worker nach getaner Arbeit beenden

// worker.js: self.onmessage = (e) => self.postMessage(e.data * 2);
const worker = new Worker('worker.js');

worker.addEventListener('message', (event) => {
  console.log('Ergebnis:', event.data);
  worker.terminate(); // Ressourcen freigeben
});

worker.postMessage(21);

Ergebnis: 42

Lange Berechnung mit Zeitlimit abbrechen

const runWithTimeout = (url, data, ms) =>
  new Promise((resolve, reject) => {
    const worker = new Worker(url);
    const timer = setTimeout(() => {
      worker.terminate();
      reject(new Error(`Zeitlimit von ${ms} ms überschritten`));
    }, ms);

    worker.onmessage = (e) => {
      clearTimeout(timer);
      worker.terminate();
      resolve(e.data);
    };
    worker.onerror = (err) => {
      clearTimeout(timer);
      worker.terminate();
      reject(err);
    };
    worker.postMessage(data);
  });

try {
  const primes = await runWithTimeout('primes.js', 1_000_000, 2000);
  console.log(`${primes.length} Primzahlen gefunden`);
} catch (err) {
  console.warn(err.message);
}

Zeitlimit von 2000 ms überschritten (falls die Berechnung zu lange dauert)

Abbruch-Button mit AbortController verknüpfen

const controller = new AbortController();
const worker = new Worker(new URL('./heavy.js', import.meta.url), { type: 'module' });

controller.signal.addEventListener('abort', () => {
  worker.terminate();
  console.log('Worker abgebrochen');
}, { once: true });

document.querySelector('#cancel').addEventListener('click', () => controller.abort());
worker.postMessage({ task: 'render' });

Worker abgebrochen

// Wichtig · Fallstricke

Kein Aufräumen: Der Worker wird hart beendet. Offene IndexedDB-Transaktionen, laufende fetch()-Anfragen oder halb geschriebene Daten werden nicht sauber abgeschlossen. Wer Aufräumlogik braucht, sollte dem Worker per postMessage() ein Stoppsignal senden und ihn sich selbst mit self.close() beenden lassen.
Keine Rückmeldung: Nach terminate() werden weder message- noch error-Ereignisse ausgelöst. Ausstehende Promises, die auf eine Worker-Antwort warten, müssen selbst abgelehnt werden, sonst bleiben sie ewig offen.
Endgültig: Ein beendeter Worker lässt sich nicht neu starten; weitere postMessage()-Aufrufe werden stillschweigend ignoriert. Für neue Arbeit muss eine neue Instanz erzeugt werden.
Mehrfaches Aufrufen ist unschädlich und wirft keinen Fehler.
SharedWorker besitzt keine terminate()-Methode; dort schließt man den Port mit port.close(). In Node.js gibt worker_threads.Worker#terminate() dagegen ein Promise zurück.
Kompatibilität: in allen modernen Browsern und auch innerhalb von Workern (verschachtelte Worker) verfügbar.

Siehe auch

Worker Worker.postMessage() DedicatedWorkerGlobalScope.close() SharedWorker new PerformanceMark()