Dart Isolates và Concurrency 2026: compute, Async và Câu Hỏi Phỏng Vấn

import 'dart:isolate';

// Phép tính nặng sẽ block UI nếu chạy trên main isolate
int computeFibonacci(int n) {
  if (n <= 1) return n;
  return computeFibonacci(n - 1) + computeFibonacci(n - 2);
}

Future<void> main() async {
  // Isolate.run() xử lý spawning, message passing, và cleanup tự động
  final result = await Isolate.run(() => computeFibonacci(40));
  print('Fibonacci(40) = $result'); // Tính toán mà không block main thread
}

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

// Hàm top-level bắt buộc cho compute() - không thể là closure hoặc 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() spawn isolate, chạy hàm, trả kết quả, dispose isolate
    return await compute(_applyGrayscaleFilter, rawImage);
  }
}

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

class IsolatePool {
  final int size;
  final List<Isolate> _isolates = [];
  final List<SendPort> _sendPorts = [];
  final List<Completer<SendPort>> _available = [];
  bool _initialized = false;

  IsolatePool({this.size = 4});

  Future<void> initialize() async {
    if (_initialized) return;
    
    for (int i = 0; i < size; i++) {
      final receivePort = ReceivePort();
      final isolate = await Isolate.spawn(_workerEntryPoint, receivePort.sendPort);
      _isolates.add(isolate);
      
      final sendPort = await receivePort.first as SendPort;
      _sendPorts.add(sendPort);
      _available.add(Completer()..complete(sendPort));
    }
    _initialized = true;
  }

  static void _workerEntryPoint(SendPort mainSendPort) {
    final receivePort = ReceivePort();
    mainSendPort.send(receivePort.sendPort);
    
    receivePort.listen((message) {
      final data = message as Map<String, dynamic>;
      final function = data['function'] as Function;
      final argument = data['argument'];
      final replyPort = data['replyPort'] as SendPort;
      
      final result = function(argument);
      replyPort.send(result);
    });
  }

  Future<R> execute<T, R>(R Function(T) function, T argument) async {
    await initialize();
    final completer = _available.removeAt(0);
    final sendPort = await completer.future;
    
    final responsePort = ReceivePort();
    sendPort.send({
      'function': function,
      'argument': argument,
      'replyPort': responsePort.sendPort,
    });
    
    final result = await responsePort.first as R;
    _available.add(Completer()..complete(sendPort));
    return result;
  }

  void dispose() {
    for (final isolate in _isolates) {
      isolate.kill();
    }
    _isolates.clear();
    _sendPorts.clear();
  }
}

import 'dart:convert';
import 'dart:isolate';
import 'package:http/http.dart' as http;

// Async/await: Hoàn hảo cho I/O operations
Future<String> fetchDataFromApi() async {
  // Thread không bị block khi chờ response HTTP
  final response = await http.get(Uri.parse('https://api.example.com/data'));
  return response.body;
}

// Isolate: Cần thiết cho tính toán CPU-intensive
Future<Map<String, dynamic>> parseHugeJson(String jsonString) async {
  // Parsing JSON lớn block event loop - chuyển sang isolate
  return await Isolate.run(() => jsonDecode(jsonString) as Map<String, dynamic>);
}

// Pattern kết hợp cho các thao tác thực tế
Future<ProcessedData> fetchAndProcessData() async {
  // Bước 1: Fetch data (I/O bound - dùng async/await)
  final rawJson = await fetchDataFromApi();
  
  // Bước 2: Parse JSON lớn (CPU bound - dùng isolate)
  final parsed = await parseHugeJson(rawJson);
  
  // Bước 3: Transform data (CPU bound - dùng isolate)
  final processed = await Isolate.run(() => transformData(parsed));
  
  return processed;
}

ProcessedData transformData(Map<String, dynamic> data) {
  // Biến đổi dữ liệu phức tạp
  return ProcessedData.fromJson(data);
}

class ProcessedData {
  final Map<String, dynamic> data;
  ProcessedData(this.data);
  factory ProcessedData.fromJson(Map<String, dynamic> json) => ProcessedData(json);
}

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

class ProgressIsolate {
  static Stream<ProgressUpdate> processWithProgress(List<int> items) async* {
    final receivePort = ReceivePort();
    
    await Isolate.spawn(
      _processItems,
      _ProcessRequest(items, receivePort.sendPort),
    );
    
    await for (final message in receivePort) {
      if (message is ProgressUpdate) {
        yield message;
      } else if (message == 'done') {
        break;
      }
    }
  }
  
  static void _processItems(_ProcessRequest request) {
    final total = request.items.length;
    var processed = 0;
    
    for (final item in request.items) {
      // Mô phỏng xử lý
      final result = item * 2;
      processed++;
      
      request.sendPort.send(ProgressUpdate(
        current: processed,
        total: total,
        result: result,
      ));
    }
    
    request.sendPort.send('done');
  }
}

class _ProcessRequest {
  final List<int> items;
  final SendPort sendPort;
  _ProcessRequest(this.items, this.sendPort);
}

class ProgressUpdate {
  final int current;
  final int total;
  final int result;
  
  ProgressUpdate({
    required this.current,
    required this.total,
    required this.result,
  });
  
  double get percentage => current / total;
}

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

class IsolateErrorHandler {
  static Future<T> runWithErrorHandling<T>(
    T Function() computation,
  ) async {
    final receivePort = ReceivePort();
    final errorPort = ReceivePort();
    
    final isolate = await Isolate.spawn(
      _runComputation<T>,
      _ComputationRequest<T>(computation, receivePort.sendPort),
      onError: errorPort.sendPort,
    );
    
    final completer = Completer<T>();
    
    receivePort.listen((message) {
      if (!completer.isCompleted) {
        completer.complete(message as T);
      }
      receivePort.close();
      errorPort.close();
      isolate.kill();
    });
    
    errorPort.listen((error) {
      if (!completer.isCompleted) {
        final errorList = error as List;
        completer.completeError(
          IsolateException(errorList[0].toString()),
          StackTrace.fromString(errorList[1].toString()),
        );
      }
      receivePort.close();
      errorPort.close();
      isolate.kill();
    });
    
    return completer.future;
  }
  
  static void _runComputation<T>(_ComputationRequest<T> request) {
    final result = request.computation();
    request.sendPort.send(result);
  }
}

class _ComputationRequest<T> {
  final T Function() computation;
  final SendPort sendPort;
  _ComputationRequest(this.computation, this.sendPort);
}

class IsolateException implements Exception {
  final String message;
  IsolateException(this.message);
  
  @override
  String toString() => 'IsolateException: $message';
}

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

// Anti-pattern: Tạo isolate cho thao tác nhỏ
Future<int> badExample(int value) async {
  // Overhead isolate lớn hơn phép tính
  return await compute((v) => v * 2, value);
}

// Pattern đúng: Dùng isolate cho batch processing
Future<List<int>> goodExample(List<int> values) async {
  // Một isolate xử lý tất cả items
  return await compute((items) => items.map((v) => v * 2).toList(), values);
}

// Pattern tốt nhất: Dùng pool cho thao tác lặp lại
class ProcessingService {
  static final IsolatePool _pool = IsolatePool(size: 4);
  
  Future<List<int>> processItems(List<int> items) async {
    return await _pool.execute(
      (data) => data.map((v) => v * 2).toList(),
      items,
    );
  }
}

class IsolatePool {
  final int size;
  IsolatePool({required this.size});
  
  Future<R> execute<T, R>(R Function(T) fn, T arg) async {
    return await Isolate.run(() => fn(arg));
  }
}