Navigator.hardwareConcurrency — Eigenschaft · JavaScript-Referenz

Signatur

Navigator.hardwareConcurrency

Beschreibung

navigator.hardwareConcurrency gibt eine ganze Zahl zurück. Sie steht für die Anzahl der logischen Prozessoren, die der Browser nutzen kann. Bei Prozessoren mit Hyperthreading bzw. SMT zählt jeder logische Kern einzeln. Ein Vierkern-Prozessor mit Hyperthreading meldet also typischerweise 8.

Am häufigsten braucht man den Wert, um die Größe eines Worker-Pools festzulegen. Rechenintensive Aufgaben wie Bildverarbeitung, Kompression, Kryptografie oder WebAssembly-Berechnungen lassen sich auf mehrere Web Worker verteilen. Mehr Worker, als es logische Kerne gibt, bringen meist keinen Gewinn. Sie verursachen dann nur zusätzlichen Aufwand für Kontextwechsel und Speicher.

Die Eigenschaft gibt es auch in Worker-Kontexten über WorkerNavigator.hardwareConcurrency, also als self.navigator.hardwareConcurrency. Behandle den Wert als Richtwert und nicht als Garantie. Der Browser kann ihn aus Datenschutzgründen begrenzen oder verfälschen. Außerdem laufen andere Prozesse und Tabs gleichzeitig auf denselben Kernen.

Rückgabewert

Typ

number

Beschreibung

Ganze Zahl ab 1: die Anzahl der logischen Prozessoren, die der Browser meldet. In Umgebungen ohne Unterstützung ist die Eigenschaft undefined.

Beispiele

Anzahl der logischen Kerne auslesen

const cores = navigator.hardwareConcurrency ?? 1;
console.log(`Verfügbare logische Prozessoren: ${cores}`);

Verfügbare logische Prozessoren: 8

Worker-Pool passend zur Kernzahl anlegen

// Einen Kern für den Haupt-Thread (UI) freihalten, mindestens 1 Worker
const poolSize = Math.max(1, (navigator.hardwareConcurrency ?? 2) - 1);

const workers = Array.from({ length: poolSize }, () =>
  new Worker(new URL('./rechner.js', import.meta.url), { type: 'module' })
);

console.log(`${workers.length} Worker gestartet`);

7 Worker gestartet

Arbeit gleichmäßig auf Worker verteilen

const runParallel = async (items, workerUrl) => {
  const n = Math.min(items.length, navigator.hardwareConcurrency ?? 2);
  const chunkSize = Math.ceil(items.length / n);

  const tasks = Array.from({ length: n }, (_, i) => {
    const chunk = items.slice(i * chunkSize, (i + 1) * chunkSize);
    return new Promise((resolve, reject) => {
      const worker = new Worker(workerUrl);
      worker.onmessage = (e) => { resolve(e.data); worker.terminate(); };
      worker.onerror = reject;
      worker.postMessage(chunk);
    });
  });

  return (await Promise.all(tasks)).flat();
};

// Aufruf: const ergebnisse = await runParallel(daten, 'worker.js');

Qualitätsstufe je nach Hardware wählen

const cores = navigator.hardwareConcurrency ?? 2;
const qualitaet = cores >= 8 ? 'hoch' : cores >= 4 ? 'mittel' : 'niedrig';
console.log(`Render-Qualität: ${qualitaet}`);

Render-Qualität: hoch

// Wichtig · Fallstricke

Datenschutz: Der Wert trägt zum Browser-Fingerprinting bei. Safari begrenzt ihn häufig (z. B. auf 4 oder 8). Firefox mit privacy.resistFingerprinting meldet immer 2. Der gemeldete Wert kann also niedriger sein als die echte Kernzahl.
Kein Auslastungswert: Die Zahl sagt nichts darüber, wie viele Kerne gerade frei sind. Auch Energiesparmodi und die Unterscheidung zwischen Performance- und Effizienzkernen (z. B. Apple M-Serie, Intel Hybrid-Architektur) sind darin nicht abgebildet.
Ersatzwert vorsehen: In älteren Browsern (z. B. Internet Explorer) fehlt die Eigenschaft. Verwende deshalb immer einen Ersatzwert mit ??.
Speicher beachten: Jeder Worker belegt eigenen Speicher. Begrenze die Pool-Größe auf Mobilgeräten zusätzlich, z. B. mithilfe von navigator.deviceMemory.
Node.js: Seit Node.js 21 gibt es navigator.hardwareConcurrency auch global. Davor verwendet man os.availableParallelism() oder os.cpus().length.

Siehe auch

Navigator NavigationCurrentEntryChangeEvent.from NavigationDestination.sameDocument Navigator.preferences Navigator.devicePosture