Parallelität und Multithreading in TypeScript: Ein vollständiger Leitfaden

Concurrency und Multithreading in TypeScript: Von der Theorie zur Praxis

Moderne Webanwendungen erfordern hohe Leistungsfähigkeit. TypeScript, das auf Node.js basiert, bietet leistungsstarke Werkzeuge zur gleichzeitigen Bearbeitung mehrerer Aufgaben. In diesem Artikel werden wir untersuchen, wie Concurrency und Multithreading in TypeScript funktionieren und lernen, sie in der Praxis anzuwenden.

Concurrency vs Parallelität: Wichtige Unterschiede

Bevor wir uns in den Code stürzen, ist es wichtig, den Unterschied zwischen Concurrency und Parallelität zu verstehen.

• Concurrency ist die Fähigkeit eines Programms, mehrere Aufgaben zu bewältigen, indem es zwischen ihnen wechselt. In JavaScript/TypeScript wird dies durch die Event-Loop und asynchrone Operationen implementiert.
• Parallelität ist die gleichzeitige Ausführung mehrerer Aufgaben auf verschiedenen CPU-Kernen. In Node.js wird dies durch Worker Threads erreicht.

TypeScript (wie JavaScript) ist von Natur aus Single-Threaded, aber dank Asynchronität und Worker Threads können wir beide Ansätze effektiv nutzen.

Asynchronität: Die Grundlage der Concurrency in TypeScript

Asynchrone Programmierung ist der erste Schritt zur Concurrency. Schauen wir uns die wichtigsten Mechanismen an.

Promises und async/await

Modernes TypeScript verwendet aktiv async/await für die Arbeit mit asynchronen Operationen. Dies ermöglicht es, Code zu schreiben, der synchron aussieht, aber gleichzeitig ausgeführt wird.

// Beispiel einer asynchronen Funktionasync function fetchData(url: string): Promise<any> {  const response = await fetch(url);  return response.json();}

// Gleichzeitige Ausführung mehrerer Anfragenasync function fetchAllData(): Promise<void> {  const [users, posts, comments] = await Promise.all([    fetchData('/api/users'),    fetchData('/api/posts'),    fetchData('/api/comments')  ]);    console.log('Alle Daten gleichzeitig geladen');}

Promise.all ermöglicht es, mehrere asynchrone Operationen gleichzeitig auszuführen, was die Ausführungszeit im Vergleich zur sequenziellen Ausführung erheblich verkürzt.

Fehlerbehandlung in asynchronem Code

Es ist wichtig, Fehler während der gleichzeitigen Ausführung korrekt zu behandeln:

async function safeFetchAll(): Promise<void> {  try {    const results = await Promise.allSettled([      fetchData('/api/users'),      fetchData('/api/invalid'),      fetchData('/api/posts')    ]);        results.forEach((result, index) => {      if (result.status === 'fulfilled') {        console.log(`Anfrage ${index} erfolgreich:`, result.value);      } else {        console.error(`Anfrage ${index} fehlgeschlagen:`, result.reason);      }    });  } catch (error) {    console.error('Kritischer Fehler:', error);  }}

Worker Threads: Echtes Multithreading in TypeScript

Für CPU-intensive Aufgaben (Bildverarbeitung, komplexe Berechnungen) reicht Asynchronität allein nicht aus. Hier kommen Worker Threads zur Rettung — echte Ausführungsthreads.

Erstellen eines Worker Threads

Schauen wir uns ein Beispiel zur Berechnung von Fibonacci-Zahlen in einem separaten Thread an:

// fibonacci.worker.tsimport { parentPort } from 'worker_threads';

function fibonacci(n: number): number {  if (n <= 1) return n;  return fibonacci(n - 1) + fibonacci(n - 2);}

parentPort?.on('message', (n: number) => {  const result = fibonacci(n);  parentPort?.postMessage(result);});

// main.tsimport { Worker } from 'worker_threads';import path from 'path';

function runFibonacci(n: number): Promise<number> {  return new Promise((resolve, reject) => {    const worker = new Worker(path.resolve(__dirname, 'fibonacci.worker.ts'));        worker.postMessage(n);        worker.on('message', (result: number) => {      resolve(result);      worker.terminate();    });        worker.on('er