Dart izolasyonları, Flutter uygulamalarında gerçek paralel yürütme sağlayarak, yoğun hesaplamalar sırasında UI takılmalarına neden olan tek iş parçacıklı sınırlamayı çözer. Diğer dillerdeki iş parçacıklarının aksine, izolasyonlar bellek paylaşmaz ve yalnızca mesaj iletimi yoluyla iletişim kurar, bu da eşzamanlı kodu daha güvenli ve anlaşılması daha kolay hale getirir.

2026 İçin Temel Bilgi

Dart 3.7, %50 azaltılmış bellek yükü ile hafif izolasyonlar tanıttı. Isolate.run() API'si artık daha önce manuel izolasyon oluşturmayı gerektiren çoğu kullanım durumunu ele alırken, compute() Flutter'a özgü iş yükleri için tercih edilen seçenek olmaya devam ediyor.

Dart Eşzamanlılık Modelini Anlama

Dart, her izolasyon içinde tek iş parçacıklı bir olay döngüsünde kod yürütür. Bu, async/await'in paralellik sağlamadığı anlamına gelir — yalnızca engellemesiz I/O işlemlerine izin verir. CPU yoğun bir görev ana izolasyonda çalıştığında, olay döngüsü kare geri çağrılarını işleyemediğinden UI donar.

Çözüm, ağır işleri ayrı izolasyonlara aktarmaktır. Her izolasyonun kendi bellek yığını ve olay döngüsü vardır ve Dart VM tarafından yönetilen ayrı bir iş parçacığında çalışır. İletişim, izolasyonlar arasında mesajları serileştiren SendPort ve ReceivePort aracılığıyla gerçekleşir.

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
}

Dart 2.19'da tanıtılan Isolate.run() fonksiyonu, bir arka plan izolasyonunda tek bir hesaplama çalıştırmanın yaygın kalıbını basitleştirir. Port oluşturma, mesaj serileştirme ve izolasyon imhasını otomatik olarak yönetir.

Flutter Uygulamalarında compute() Kullanımı

Flutter, UI izolasyonundan iş aktarmak için özel olarak tasarlanmış compute() fonksiyonunu sağlar. Ham izolasyon API'lerinin aksine, compute() Flutter framework'ü ile entegre olur ve izolasyon yönetiminin standart kodunu ele alır.

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

compute()'a geçirilen fonksiyon, üst düzey bir fonksiyon veya statik bir metot olmalıdır. Örnek metotları ve closure'lar, izolasyon sınırları arasında serileştirilemeyen durumu yakalar.

Yaygın Tuzak

Serileştirilemeyen nesneleri izolasyonlara geçirmek çalışma zamanı hatalarına neden olur. Sınıflar basit veri nesneleri olmalıdır — BuildContext yok, Stream referansları yok, singleton yok. Hesaplama için yalnızca gerekli olan ilkel verileri çıkarın.

Portlarla Çift Yönlü İletişim

Karmaşık senaryolar, tek bir istek-yanıt döngüsü yerine izolasyonlar arasında sürekli iletişim gerektirir. Uzun süreli arka plan görevleri, akış veri işleme ve işçi havuzlarının tümü çift yönlü mesaj iletimi gerektirir.

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

Bu kalıp, zaman içinde birden fazla görevi kabul eden kalıcı bir işçi izolasyonu oluşturur. Ana izolasyon görevleri SendPort aracılığıyla gönderir ve işçi kendi portu aracılığıyla yanıt verir. İşçi izolasyonundaki durum görevler arasında kalıcıdır ve önbelleğe alma ile artımlı işlemeyi mümkün kılar.

Async/Await vs İzolasyonlar: Doğru Aracı Seçmek

Yaygın bir Flutter geliştiricileri için mülakat sorusu, async/await ile izolasyonların ne zaman kullanılacağını sorar. Bu ayrım uygulama performansı için önemlidir.

| Senaryo | async/await kullan | İzolasyon kullan | |----------|-----------------|-------------| | Ağ istekleri | Evet | Hayır | | Dosya I/O | Evet | Hayır | | JSON ayrıştırma (küçük) | Evet | Hayır | | JSON ayrıştırma (>1MB) | Hayır | Evet | | Görüntü işleme | Hayır | Evet | | Kriptografik işlemler | Hayır | Evet | | Veritabanı sorguları | Evet | Bazen | | Karmaşık hesaplamalar | Hayır | Evet |

Async/await, Dart VM beklemeyi işletim sistemine devrettiği için I/O bağlı işlemleri verimli bir şekilde yönetir. Olay döngüsü UI olaylarını işlemek için serbest kalır. İzolasyonlar, I/O'dan bağımsız olarak hesaplamanın kendisinin zaman tükettiği CPU bağlı sorunları çözer.

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

Flutter mülakatlarında başarılı olmaya hazır mısın?

İnteraktif simülatörler, flashcards ve teknik testlerle pratik yap.

Flutter keşfet

İzolasyon Sınırları Arasında Hata Yönetimi

İzolasyonlarda fırlatılan hatalar otomatik olarak çağıran izolasyona yayılmaz. Uygun işleme olmadan, istisnalar sessizce kaybolur ve üretim uygulamalarında hata ayıklaması zor sorunlara neden olur.

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

Sarmalayıcı kalıbı, izolasyon içindeki istisnaları yakalar ve bunları veri olarak döndürerek hataların çağıran kodda ortaya çıkmasını sağlar. Bu yaklaşım, Rust'ta kullanılan Result kalıbını yansıtır ve fonksiyonel hata yönetimi uygulamalarıyla uyumludur.

İzolasyon Havuzlarıyla Performans Optimizasyonu

İzolasyon oluşturma yük getirir — bellek tahsisi, yeni izolasyondaki kodun JIT derlemesi ve mesaj serileştirme. Birçok bağımsız görevi işleyen uygulamalar için, bir havuz aracılığıyla izolasyonları yeniden kullanmak verimi artırır.

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());
  });
}

Havuz, iş kabul etmeye hazır sabit sayıda ısınmış izolasyon tutar. Tüm izolasyonlar meşgul olduğunda görevler sıraya girer ve tamamlanan izolasyonlar hemen kullanılabilir havuza döner.

Dart Eşzamanlılığı Hakkında Yaygın Mülakat Soruları

Teknik mülakatlar sıklıkla Dart'ın eşzamanlılık modelinin anlaşılmasını araştırır. Bu sorulara hazırlık, temel Flutter widget bilgisinin ötesinde derinlik gösterir. Flutter mülakat soruları modülü ek widget ve durum yönetimi konularını kapsar.

S: Bir izolasyondan setState() çağırırsanız ne olur?

Bir arka plan izolasyonundan setState() çağırmak başarısız olur çünkü BuildContext ve widget durumu yalnızca ana izolasyonun belleğinde bulunur. İzolasyon, ana izolasyon nesnelerine doğrudan erişemez. Bunun yerine, hesaplanan sonucu ana izolasyona geri gönderin ve orada setState() çağırın:

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

S: İzolasyonlar nesneleri paylaşabilir mi?

İzolasyonlar değiştirilebilir nesneleri paylaşamaz. Her izolasyonun kendi yığını vardır ve izolasyonlar arasında geçirilen nesneler serileştirilir ve kopyalanır. Dart transferlerini optimize ettiği için değişmez nesneler ve ilkel türler verimli bir şekilde geçirilebilir. Değiştirilebilir durum, mesaj iletimi yoluyla açık senkronizasyon gerektirir.

S: async/await izolasyonlarla nasıl çalışır?

Bir izolasyon içindeki async/await, ana izolasyonla aynı şekilde çalışır — her izolasyonun kendi olay döngüsü vardır. Bir izolasyonda Future beklemek, ana izolasyonun olay döngüsünü engellemez. Isolate.run() fonksiyonunun kendisi, izolasyon bittiğinde tamamlanan bir Future döndürerek ana izolasyondaki async kodla sorunsuz bir şekilde entegre olur.

İzolasyon Tabanlı Kodda Hata Ayıklama

Çoklu izolasyon uygulamalarında hata ayıklama, kesme noktalarının ve günlüğün izolasyon sınırları arasında farklı davrandığını anlamayı gerektirir.

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

Flutter DevTools performans görünümü, tüm izolasyonlardan zaman çizelgesi olaylarını göstererek paralel yürütmeyi görselleştirmeyi ve darboğazları belirlemeyi mümkün kılar.

DevTools İpucu

DevTools'daki CPU Profiler, hangi izolasyonların en fazla işlem süresi tükettiğini belirlemeye yardımcı olur. Alev grafiği yürütmeyi izolasyona göre ayırarak işin düzgün dağıtılıp dağıtılmadığını ortaya koyar.

Sonuç

İzolasyonlar, izole bellek yığınlarıyla ayrı iş parçacıklarında çalışarak Dart'ta gerçek paralellik sağlar
Basit tek seferlik hesaplamalar için Isolate.run(), Flutter'a özgü iş yükleri için compute() kullanın
Async/await I/O bağlı işleri yönetir; izolasyonlar olay döngüsünü engelleyen CPU bağlı sorunları çözer
İzolasyonlara geçirilen fonksiyonlar üst düzey veya statik olmalıdır — closure'lar ve örnek metotlar serileştirmede başarısız olur
İzolasyonlar içinde hata yönetimi uygulayın ve istisnaların düzgün şekilde ortaya çıkmasını sağlamak için hataları veri olarak döndürün
İzolasyon havuzları, birçok bağımsız görevi işleyen uygulamalar için oluşturma yükünü azaltır
Flutter durum yönetimi modülü mülakat hazırlığı için eşzamanlılık bilgisini tamamlar

Pratik yapmaya başla!

Mülakat simülatörleri ve teknik testlerle bilgini test et.

Ücretsiz hesabımı oluştur

Dart Isolates ve 2026'da Eşzamanlılık: compute, Async ve Mülakat Soruları