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

> Flutter uygulamaları için Dart izolasyonları, compute fonksiyonu ve async kalıplarında uzmanlaşın. Eşzamanlılık modelleri, performans optimizasyonu ve kod örnekleriyle yaygın mülakat sorularını kapsar.

- Published: 2026-07-13
- Updated: 2026-07-13
- Author: SharpSkill
- Tags: dart, flutter, isolates, concurrency, async, performance
- Reading time: 12 min

---

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.

```dart
// main.dart
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.

```dart
// image_processor.dart
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.

```dart
// background_worker.dart
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](/technologies/flutter/interview-questions/state-management-basics), 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.

```dart
// json_service.dart
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>;
}
```

## İ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.

```dart
// safe_isolate.dart
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ı](https://doc.rust-lang.org/std/result/) 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.

```dart
// isolate_pool.dart
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ü](/technologies/flutter) 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:

```dart
// counter_page.dart
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.

```dart
// debug_utils.dart
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](https://docs.flutter.dev/tools/devtools/overview) 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ü](/technologies/flutter/interview-questions/state-management-basics) mülakat hazırlığı için eşzamanlılık bilgisini tamamlar

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/tr/blog/flutter/dart-isolates-concurrency-2026-compute-async-interview