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';
}