Dart Isolates ermöglichen echte Parallelverarbeitung in Flutter-Anwendungen und lösen die Single-Thread-Einschränkung, die bei rechenintensiven Operationen zu UI-Rucklern führt. Im Gegensatz zu Threads in anderen Sprachen teilen Isolates keinen Speicher und kommunizieren ausschließlich über Message Passing, was nebenläufigen Code sicherer und verständlicher macht.

Wichtige Neuerung 2026

Dart 3.7 führte leichtgewichtige Isolates mit 50% reduziertem Speicherverbrauch ein. Die Isolate.run() API deckt nun die meisten Anwendungsfälle ab, für die früher manuelles Isolate-Spawning erforderlich war, während compute() weiterhin die erste Wahl für Flutter-spezifische Workloads bleibt.

Das Dart Nebenläufigkeitsmodell verstehen

Dart führt Code in einer Single-Threaded Event-Loop innerhalb jedes Isolates aus. Das bedeutet, dass async/await keine Parallelität bietet – es ermöglicht lediglich nicht-blockierende I/O-Operationen. Wenn eine CPU-intensive Aufgabe im Main-Isolate läuft, friert die UI ein, da die Event-Loop keine Frame-Callbacks verarbeiten kann.

Die Lösung besteht darin, schwere Arbeit in separate Isolates auszulagern. Jedes Isolate verfügt über einen eigenen Speicherbereich und eine eigene Event-Loop, die auf einem separaten Thread läuft, der von der Dart VM verwaltet wird. Die Kommunikation erfolgt über SendPort und ReceivePort, die Nachrichten zwischen Isolates serialisieren.

main.dartdart

import 'dart:isolate';

// Heavy computation that would block the UI if run on main isolate
int computeFibonacci(int n) {
  if (n <= 1) return n;
  return computeFibonacci(n - 1) + computeFibonacci(n - 2);
}

Future<void> main() async {
  // Isolate.run() handles spawning, message passing, and cleanup automatically
  final result = await Isolate.run(() => computeFibonacci(40));
  print('Fibonacci(40) = $result'); // Computed without blocking main thread
}

Die mit Dart 2.19 eingeführte Isolate.run() Funktion vereinfacht das gängige Pattern, eine einzelne Berechnung in einem Hintergrund-Isolate auszuführen. Sie übernimmt automatisch Port-Erstellung, Nachrichtenserialisierung und Isolate-Disposal.

Verwendung von compute() in Flutter-Anwendungen

Flutter stellt die compute() Funktion bereit, die speziell dafür entwickelt wurde, Arbeit vom UI-Isolate auszulagern. Im Gegensatz zu den rohen Isolate-APIs integriert sich compute() mit dem Flutter-Framework und übernimmt den Boilerplate-Code des Isolate-Managements.

image_processor.dartdart

import 'dart:typed_data';
import 'package:flutter/foundation.dart';
import 'package:image/image.dart' as img;

// Top-level function required for compute() - cannot be a closure or method
Uint8List _applyGrayscaleFilter(Uint8List imageBytes) {
  final image = img.decodeImage(imageBytes)!;
  final grayscale = img.grayscale(image);
  return Uint8List.fromList(img.encodePng(grayscale));
}

class ImageProcessor {
  Future<Uint8List> processImage(Uint8List rawImage) async {
    // compute() spawns isolate, runs function, returns result, disposes isolate
    return await compute(_applyGrayscaleFilter, rawImage);
  }
}

Die an compute() übergebene Funktion muss eine Top-Level-Funktion oder eine statische Methode sein. Instanzmethoden und Closures erfassen Zustand, der nicht über Isolate-Grenzen serialisiert werden kann.

Häufiger Fehler

Das Übergeben von nicht-serialisierbaren Objekten an Isolates verursacht Laufzeitfehler. Klassen müssen einfache Datenobjekte sein – kein BuildContext, keine Stream-Referenzen, keine Singletons. Es sollten nur die primitiven Daten extrahiert werden, die für die Berechnung benötigt werden.

Bidirektionale Kommunikation mit Ports

Komplexe Szenarien erfordern fortlaufende Kommunikation zwischen Isolates statt eines einzelnen Request-Response-Zyklus. Lang laufende Hintergrundaufgaben, Streaming-Datenverarbeitung und Worker-Pools benötigen alle bidirektionales Message Passing.

background_worker.dartdart

import 'dart:isolate';
import 'dart:async';

class BackgroundWorker {
  late Isolate _isolate;
  late SendPort _sendPort;
  final _responseController = StreamController<dynamic>.broadcast();
  
  Stream<dynamic> get responses => _responseController.stream;

  Future<void> start() async {
    final receivePort = ReceivePort();
    
    // Spawn isolate with initial SendPort for bidirectional setup
    _isolate = await Isolate.spawn(_workerEntryPoint, receivePort.sendPort);
    
    // First message from worker contains its SendPort
    final completer = Completer<SendPort>();
    receivePort.listen((message) {
      if (message is SendPort) {
        completer.complete(message);
      } else {
        _responseController.add(message); // Forward results to stream
      }
    });
    
    _sendPort = await completer.future;
  }

  void sendTask(Map<String, dynamic> task) {
    _sendPort.send(task);
  }

  void dispose() {
    _isolate.kill(priority: Isolate.immediate);
    _responseController.close();
  }
}

// Entry point runs in the background isolate
void _workerEntryPoint(SendPort mainSendPort) {
  final workerReceivePort = ReceivePort();
  mainSendPort.send(workerReceivePort.sendPort); // Send port back to main
  
  workerReceivePort.listen((message) {
    final task = message as Map<String, dynamic>;
    final result = _processTask(task); // Heavy computation here
    mainSendPort.send(result);
  });
}

dynamic _processTask(Map<String, dynamic> task) {
  // Simulate CPU-intensive work
  return {'taskId': task['id'], 'processed': true};
}

Dieses Pattern etabliert ein persistentes Worker-Isolate, das über Zeit mehrere Aufgaben annimmt. Das Main-Isolate sendet Aufgaben über SendPort, und der Worker antwortet über seinen eigenen Port. Der Zustand innerhalb des Worker-Isolates bleibt zwischen Aufgaben erhalten, was Caching und inkrementelle Verarbeitung ermöglicht.

Async/Await vs Isolates: Das richtige Werkzeug wählen

Eine häufige Interviewfrage für Flutter-Entwickler betrifft die Entscheidung zwischen async/await und Isolates. Die Unterscheidung ist wichtig für die Anwendungsperformance.

| Szenario | async/await verwenden | Isolates verwenden | |----------|----------------------|--------------------| | Netzwerkanfragen | Ja | Nein | | Datei-I/O | Ja | Nein | | JSON-Parsing (klein) | Ja | Nein | | JSON-Parsing (>1MB) | Nein | Ja | | Bildverarbeitung | Nein | Ja | | Kryptografische Operationen | Nein | Ja | | Datenbankabfragen | Ja | Manchmal | | Komplexe Berechnungen | Nein | Ja |

Async/await behandelt I/O-gebundene Operationen effizient, da die Dart VM das Warten an das Betriebssystem delegiert. Die Event-Loop bleibt frei, um UI-Events zu verarbeiten. Isolates lösen CPU-gebundene Probleme, bei denen die Berechnung selbst Zeit verbraucht, unabhängig von I/O.

json_service.dartdart

import 'dart:convert';
import 'package:flutter/foundation.dart';

class JsonService {
  // Small payloads: async is sufficient, isolate overhead not justified
  Future<Map<String, dynamic>> parseSmallJson(String json) async {
    return jsonDecode(json) as Map<String, dynamic>;
  }

  // Large payloads: isolate prevents UI jank during parsing
  Future<List<dynamic>> parseLargeJson(String json) async {
    return await compute(_parseJsonList, json);
  }
}

List<dynamic> _parseJsonList(String json) {
  return jsonDecode(json) as List<dynamic>;
}

Bereit für deine Flutter-Interviews?

Übe mit unseren interaktiven Simulatoren, Flashcards und technischen Tests.

Flutter erkunden

Fehlerbehandlung über Isolate-Grenzen

Fehler, die in Isolates geworfen werden, propagieren nicht automatisch zum aufrufenden Isolate. Ohne korrekte Behandlung verschwinden Exceptions stillschweigend und verursachen schwer zu debuggende Probleme in Produktions-Apps.

safe_isolate.dartdart

import 'dart:isolate';

class IsolateResult<T> {
  final T? value;
  final Object? error;
  final StackTrace? stackTrace;
  
  IsolateResult.success(this.value) : error = null, stackTrace = null;
  IsolateResult.failure(this.error, this.stackTrace) : value = null;
  
  bool get isSuccess => error == null;
}

Future<IsolateResult<T>> runSafeIsolate<T>(T Function() computation) async {
  try {
    final result = await Isolate.run(() {
      try {
        return IsolateResult<T>.success(computation());
      } catch (e, stack) {
        return IsolateResult<T>.failure(e, stack);
      }
    });
    return result;
  } catch (e, stack) {
    // Handle isolate spawn failures
    return IsolateResult<T>.failure(e, stack);
  }
}

// Usage
Future<void> processData() async {
  final result = await runSafeIsolate(() => riskyComputation());
  
  if (result.isSuccess) {
    print('Result: ${result.value}');
  } else {
    print('Error: ${result.error}');
    print('Stack: ${result.stackTrace}');
  }
}

int riskyComputation() {
  throw Exception('Something went wrong');
}

Das Wrapper-Pattern fängt Exceptions innerhalb des Isolates ab und gibt sie als Daten zurück, wodurch sichergestellt wird, dass Fehler im aufrufenden Code auftauchen. Dieser Ansatz spiegelt das Result-Pattern aus Rust wider und entspricht funktionalen Fehlerbehandlungspraktiken.

Performance-Optimierung mit Isolate-Pools

Das Spawnen von Isolates verursacht Overhead – Speicherallokation, JIT-Kompilierung von Code im neuen Isolate und Nachrichtenserialisierung. Für Anwendungen, die viele unabhängige Aufgaben verarbeiten, verbessert die Wiederverwendung von Isolates durch einen Pool den Durchsatz.

isolate_pool.dartdart

import 'dart:async';
import 'dart:collection';
import 'dart:isolate';

class IsolatePool {
  final int size;
  final Queue<_PooledIsolate> _available = Queue();
  final List<_PooledIsolate> _all = [];
  bool _initialized = false;

  IsolatePool({this.size = 4});

  Future<void> initialize() async {
    if (_initialized) return;
    
    for (int i = 0; i < size; i++) {
      final pooled = await _PooledIsolate.spawn();
      _all.add(pooled);
      _available.add(pooled);
    }
    _initialized = true;
  }

  Future<R> execute<R>(R Function() task) async {
    if (!_initialized) await initialize();
    
    // Wait for available isolate
    while (_available.isEmpty) {
      await Future.delayed(const Duration(milliseconds: 10));
    }
    
    final isolate = _available.removeFirst();
    try {
      return await isolate.run(task);
    } finally {
      _available.add(isolate); // Return to pool
    }
  }

  Future<void> dispose() async {
    for (final isolate in _all) {
      isolate.dispose();
    }
    _all.clear();
    _available.clear();
  }
}

class _PooledIsolate {
  final Isolate isolate;
  final SendPort sendPort;
  final ReceivePort receivePort;

  _PooledIsolate._(this.isolate, this.sendPort, this.receivePort);

  static Future<_PooledIsolate> spawn() async {
    final receivePort = ReceivePort();
    final isolate = await Isolate.spawn(_poolWorker, receivePort.sendPort);
    final sendPort = await receivePort.first as SendPort;
    return _PooledIsolate._(isolate, sendPort, receivePort);
  }

  Future<R> run<R>(R Function() task) async {
    final responsePort = ReceivePort();
    sendPort.send([task, responsePort.sendPort]);
    return await responsePort.first as R;
  }

  void dispose() {
    isolate.kill();
    receivePort.close();
  }
}

void _poolWorker(SendPort mainPort) {
  final workerPort = ReceivePort();
  mainPort.send(workerPort.sendPort);
  
  workerPort.listen((message) {
    final task = message[0] as Function;
    final replyPort = message[1] as SendPort;
    replyPort.send(task());
  });
}

Der Pool pflegt eine feste Anzahl von aufgewärmten Isolates, die bereit sind, Arbeit anzunehmen. Aufgaben werden in eine Warteschlange gestellt, wenn alle Isolates beschäftigt sind, und fertige Isolates kehren sofort zum verfügbaren Pool zurück.

Häufige Interviewfragen zu Dart Nebenläufigkeit

Technische Interviews prüfen häufig das Verständnis von Darts Nebenläufigkeitsmodell. Die Vorbereitung auf diese Fragen demonstriert Tiefenwissen über grundlegendes Flutter-Widget-Wissen hinaus. Das Flutter Interviewfragen-Modul behandelt zusätzliche Widget- und State-Management-Themen.

F: Was passiert, wenn setState() aus einem Isolate aufgerufen wird?

Der Aufruf von setState() aus einem Hintergrund-Isolate schlägt fehl, da BuildContext und Widget-State nur im Speicher des Main-Isolates existieren. Das Isolate kann nicht direkt auf Objekte des Main-Isolates zugreifen. Stattdessen sollte das berechnete Ergebnis zum Main-Isolate zurückgesendet und dort setState() aufgerufen werden:

counter_page.dartdart

import 'dart:isolate';
import 'package:flutter/material.dart';

class CounterPage extends StatefulWidget {
  const CounterPage({super.key});
  @override
  State<CounterPage> createState() => _CounterPageState();
}

class _CounterPageState extends State<CounterPage> {
  int _result = 0;
  bool _computing = false;

  Future<void> _computeInBackground() async {
    setState(() => _computing = true);
    
    // Computation runs in isolate
    final result = await Isolate.run(() => _heavyCalculation(1000000));
    
    // setState called on main isolate after receiving result
    setState(() {
      _result = result;
      _computing = false;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Text('Result: $_result'),
        ElevatedButton(
          onPressed: _computing ? null : _computeInBackground,
          child: _computing 
              ? const CircularProgressIndicator() 
              : const Text('Compute'),
        ),
      ],
    );
  }
}

int _heavyCalculation(int iterations) {
  int sum = 0;
  for (int i = 0; i < iterations; i++) {
    sum += i;
  }
  return sum;
}

F: Können Isolates Objekte teilen?

Isolates können keine veränderlichen Objekte teilen. Jedes Isolate hat seinen eigenen Heap, und Objekte, die zwischen Isolates übergeben werden, werden serialisiert und kopiert. Unveränderliche Objekte und Primitive können effizient übertragen werden, da Dart deren Transfer optimiert. Veränderlicher Zustand erfordert explizite Synchronisation durch Message Passing.

F: Wie funktioniert async/await mit Isolates?

Async/await innerhalb eines Isolates funktioniert identisch wie im Main-Isolate – jedes Isolate hat seine eigene Event-Loop. Das Awaiten eines Futures in einem Isolate blockiert nicht die Event-Loop des Main-Isolates. Die Isolate.run() Funktion selbst gibt ein Future zurück, das abgeschlossen wird, wenn das Isolate fertig ist, und integriert sich nahtlos mit async-Code im Main-Isolate.

Debugging von Isolate-basiertem Code

Das Debuggen von Multi-Isolate-Anwendungen erfordert das Verständnis, dass Breakpoints und Logging sich über Isolate-Grenzen hinweg unterschiedlich verhalten.

debug_utils.dartdart

import 'dart:developer' as developer;
import 'dart:isolate';

void debugPrint(String message) {
  // developer.log works across isolates and appears in DevTools
  developer.log(
    message,
    name: 'IsolateDebug',
    time: DateTime.now(),
  );
}

Future<void> debuggableComputation() async {
  await Isolate.run(() {
    debugPrint('Starting computation in isolate');
    
    // Timeline events visible in DevTools performance tab
    developer.Timeline.startSync('HeavyWork');
    final result = performHeavyWork();
    developer.Timeline.finishSync();
    
    debugPrint('Computation complete: $result');
    return result;
  });
}

int performHeavyWork() {
  int sum = 0;
  for (int i = 0; i < 10000000; i++) {
    sum += i;
  }
  return sum;
}

Die Performance-Ansicht der Flutter DevTools zeigt Timeline-Events von allen Isolates und ermöglicht es, parallele Ausführung zu visualisieren und Engpässe zu identifizieren.

DevTools-Tipp

Der CPU Profiler in DevTools zeigt, welche Isolates die meiste Verarbeitungszeit verbrauchen. Das Flame-Chart trennt die Ausführung nach Isolate auf und offenbart, ob die Arbeit korrekt verteilt ist.

Fazit

Isolates bieten echte Parallelität in Dart und laufen auf separaten Threads mit isolierten Speicherbereichen
Isolate.run() eignet sich für einfache einmalige Berechnungen, compute() für Flutter-spezifische Workloads
Async/await behandelt I/O-gebundene Arbeit; Isolates lösen CPU-gebundene Probleme, die die Event-Loop blockieren
Funktionen, die an Isolates übergeben werden, müssen Top-Level oder statisch sein – Closures und Instanzmethoden scheitern bei der Serialisierung
Fehlerbehandlung innerhalb von Isolates implementieren und Fehler als Daten zurückgeben, um sicherzustellen, dass Exceptions korrekt auftauchen
Isolate-Pools reduzieren den Spawn-Overhead für Anwendungen, die viele unabhängige Aufgaben verarbeiten
Das Flutter State-Management-Modul ergänzt das Nebenläufigkeitswissen für die Interviewvorbereitung

Fang an zu üben!

Teste dein Wissen mit unseren Interview-Simulatoren und technischen Tests.

Kostenloses Konto erstellen

Dart Isolates und Nebenläufigkeit 2026: compute, Async und Interviewfragen