Dart IsolatesとFlutter並行処理 2026年完全ガイド：compute、非同期処理、面接対策

import 'dart:isolate';

void main() async {
  // 新しいIsolateを生成してメッセージを受信
  final receivePort = ReceivePort();
  
  await Isolate.spawn(
    heavyComputation,
    receivePort.sendPort,
  );
  
  // 結果を受信
  final result = await receivePort.first;
  print('Result: $result');
}

void heavyComputation(SendPort sendPort) {
  // 重い計算処理
  int sum = 0;
  for (int i = 0; i < 1000000000; i++) {
    sum += i;
  }
  sendPort.send(sum);
}

// 悪い例：メインIsolateでの重い処理
class BadExample extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: () {
        // UIがフリーズする
        final result = parseHugeJsonFile(jsonString);
        print(result);
      },
      child: Text('Parse JSON'),
    );
  }
}

// 良い例：Isolateを使用した非同期処理
class GoodExample extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: () async {
        // UIはスムーズに動作し続ける
        final result = await Isolate.run(() => parseHugeJsonFile(jsonString));
        print(result);
      },
      child: Text('Parse JSON'),
    );
  }
}

import 'dart:isolate';

class ImageProcessor {
  Future<Uint8List> processImage(Uint8List imageData) async {
    // 別Isolateで画像処理を実行
    return await Isolate.run(() {
      // 重い画像処理
      return applyFilters(imageData);
    });
  }
  
  static Uint8List applyFilters(Uint8List data) {
    // ガウシアンブラー、色調補正などの処理
    // ...
    return processedData;
  }
}

import 'package:flutter/foundation.dart';

class DataParser {
  Future<List<Product>> parseProducts(String jsonString) async {
    // compute関数でJSON解析を別Isolateで実行
    return await compute(_parseProductsJson, jsonString);
  }
  
  // トップレベル関数または静的メソッドである必要がある
  static List<Product> _parseProductsJson(String json) {
    final List<dynamic> data = jsonDecode(json);
    return data.map((item) => Product.fromJson(item)).toList();
  }
}

class Product {
  final String id;
  final String name;
  final double price;
  
  Product({required this.id, required this.name, required this.price});
  
  factory Product.fromJson(Map<String, dynamic> json) {
    return Product(
      id: json['id'],
      name: json['name'],
      price: json['price'].toDouble(),
    );
  }
}

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

class WorkerIsolate {
  late Isolate _isolate;
  late SendPort _sendPort;
  final ReceivePort _receivePort = ReceivePort();
  final Completer<void> _ready = Completer<void>();
  
  Future<void> start() async {
    _isolate = await Isolate.spawn(
      _workerEntryPoint,
      _receivePort.sendPort,
    );
    
    // ワーカーからのSendPortを受信
    _sendPort = await _receivePort.first as SendPort;
    _ready.complete();
  }
  
  Future<dynamic> sendMessage(dynamic message) async {
    await _ready.future;
    final responsePort = ReceivePort();
    _sendPort.send([message, responsePort.sendPort]);
    return await responsePort.first;
  }
  
  void dispose() {
    _isolate.kill();
    _receivePort.close();
  }
  
  static void _workerEntryPoint(SendPort mainSendPort) {
    final workerReceivePort = ReceivePort();
    mainSendPort.send(workerReceivePort.sendPort);
    
    workerReceivePort.listen((message) {
      final data = message[0];
      final replyPort = message[1] as SendPort;
      
      // 処理を実行
      final result = processData(data);
      replyPort.send(result);
    });
  }
  
  static dynamic processData(dynamic data) {
    // データ処理ロジック
    return data;
  }
}

// async/awaitは並行処理ではない
Future<void> fetchData() async {
  // ネットワークI/Oの待機中は他の処理が実行される
  final response = await http.get(Uri.parse('https://api.example.com/data'));
  
  // JSONパースはメインIsolateで実行される
  // 大きなJSONの場合、UIがブロックされる可能性がある
  final data = jsonDecode(response.body);
}

// Isolateを使用した真の並行処理
Future<void> fetchDataWithIsolate() async {
  final response = await http.get(Uri.parse('https://api.example.com/data'));
  
  // JSONパースを別Isolateで実行
  final data = await Isolate.run(() => jsonDecode(response.body));
}

class IsolatePool {
  final List<WorkerIsolate> _workers = [];
  int _currentIndex = 0;
  
  Future<void> initialize(int poolSize) async {
    for (int i = 0; i < poolSize; i++) {
      final worker = WorkerIsolate();
      await worker.start();
      _workers.add(worker);
    }
  }
  
  Future<dynamic> execute(dynamic task) async {
    final worker = _workers[_currentIndex];
    _currentIndex = (_currentIndex + 1) % _workers.length;
    return await worker.sendMessage(task);
  }
  
  void dispose() {
    for (final worker in _workers) {
      worker.dispose();
    }
  }
}

import 'dart:typed_data';

void transferLargeData(SendPort sendPort) {
  final largeData = Uint8List(10000000);
  // ゼロコピー転送
  final transferable = TransferableTypedData.fromList([largeData]);
  sendPort.send(transferable);
}

Future<T> runIsolateWithErrorHandling<T>(Future<T> Function() computation) async {
  try {
    return await Isolate.run(computation);
  } on IsolateSpawnException catch (e) {
    // Isolate生成に失敗した場合
    throw ComputationException('Failed to spawn isolate: $e');
  } catch (e, stackTrace) {
    // Isolate内での例外
    throw ComputationException('Computation failed: $e', stackTrace);
  }
}

class ComputationException implements Exception {
  final String message;
  final StackTrace? stackTrace;
  
  ComputationException(this.message, [this.stackTrace]);
  
  @override
  String toString() => 'ComputationException: $message';
}