WorkerNavigator.hardwareConcurrency — Eigenschaft · JavaScript-Referenz

Signatur

get WorkerNavigator.hardwareConcurrency

Beschreibung

Die schreibgeschützte Eigenschaft hardwareConcurrency des WorkerNavigator-Objekts gibt eine Ganzzahl zurück, die angibt, wie viele logische Prozessoren (Kerne inklusive Hyper-Threads) für die parallele Ausführung von Threads verfügbar sind. Innerhalb eines Web Workers liest man sie über self.navigator.hardwareConcurrency oder kurz navigator.hardwareConcurrency, im Hauptthread steht dieselbe Eigenschaft auf window.navigator zur Verfügung.

Am häufigsten wird sie verwendet, um die Größe eines Worker-Pools festzulegen: Rechenintensive Aufgaben wie Bildverarbeitung, Kompression, Hashing oder WebAssembly-Berechnungen lassen sich auf so viele Worker aufteilen, wie Kerne vorhanden sind. Mehr Worker als logische Prozessoren bringen in der Regel keinen Geschwindigkeitsgewinn, sondern nur zusätzlichen Aufwand für Kontextwechsel.

Der Wert ist nur ein Hinweis: Der Browser kann ihn aus Datenschutzgründen (Fingerprinting) absichtlich kleiner angeben oder auf einen festen Wert begrenzen. Außerdem sagt er nichts darüber aus, wie viele Kerne gerade tatsächlich frei sind, denn andere Programme und Tabs konkurrieren um dieselbe CPU.

Rückgabewert

Typ

number

Beschreibung

Positive Ganzzahl (mindestens 1) mit der Anzahl der vom Browser gemeldeten logischen Prozessoren.

Beispiele

Kernanzahl im Worker auslesen

// worker.js
const kerne = self.navigator.hardwareConcurrency;
self.postMessage({ typ: 'info', kerne });

// main.js
const worker = new Worker('worker.js');
worker.addEventListener('message', (event) => {
  console.log(`Logische Prozessoren: ${event.data.kerne}`);
});

Logische Prozessoren: 8

Worker-Pool passend zur Hardware anlegen

// Einen Kern für den Hauptthread freihalten, mindestens 1 Worker, höchstens 8
const anzahl = Math.min(Math.max((navigator.hardwareConcurrency ?? 2) - 1, 1), 8);

const pool = Array.from({ length: anzahl }, () => new Worker('rechner.js'));
console.log(`Pool mit ${pool.length} Workern gestartet`);

Pool mit 7 Workern gestartet

Arbeit gleichmäßig auf Worker verteilen

const rechneParallel = async (daten) => {
  const n = navigator.hardwareConcurrency || 4;
  const blockGroesse = Math.ceil(daten.length / n);

  const auftraege = Array.from({ length: n }, (_, i) => {
    const teil = daten.slice(i * blockGroesse, (i + 1) * blockGroesse);
    return new Promise((resolve) => {
      const w = new Worker('summe.js');
      w.onmessage = (e) => { resolve(e.data); w.terminate(); };
      w.postMessage(teil);
    });
  });

  const teilsummen = await Promise.all(auftraege);
  return teilsummen.reduce((a, b) => a + b, 0);
};

// summe.js:
// self.onmessage = (e) => self.postMessage(e.data.reduce((a, b) => a + b, 0));

rechneParallel(Array.from({ length: 1_000_000 }, (_, i) => i))
  .then((summe) => console.log(summe));

499999500000

// Wichtig · Fallstricke

Datenschutz: Der Wert kann zum Fingerprinting beitragen. Safari begrenzt ihn z. B. auf 4 oder 8, Firefox mit privacy.resistFingerprinting meldet 2. Verlasse dich nicht auf einen exakten Wert.
Kein Maß für freie Kapazität: Die Zahl beschreibt die Hardware, nicht die aktuelle Auslastung. Begrenze Pools sinnvoll nach oben und halte einen Kern für den Hauptthread frei.
Fallback: Ältere Browser (z. B. Internet Explorer) kennen die Eigenschaft nicht. Nutze einen Standardwert wie navigator.hardwareConcurrency ?? 4.
Die Eigenschaft ist schreibgeschützt. Eine Zuweisung wird stillschweigend ignoriert (im Strict Mode bei Getter-only-Eigenschaften teils mit TypeError).
In Node.js gibt es seit Version 21 ebenfalls navigator.hardwareConcurrency. Alternativ lässt sich os.availableParallelism() verwenden.

Siehe auch

Worker Navigator.hardwareConcurrency WorkerNavigator.appCodeName WorkerNavigator.serviceWorker WorkerNavigator.appVersion