Bölüm 13 — Konu 61: Event Loop Derinlemesine — Microtask Queue vs Event Queue

Bölüm 10'da Future/async/await'i kullanmayı öğrenmiştik. Bu derste, bunların arka planda tam olarak nasıl çalıştığını — Dart'ın "event loop" mekanizmasını — işleyeceğiz.

#Tek İş Parçacığı, Ama Nasıl "Eşzamanlı" Görünüyor?

Bölüm 12'de Dart'ın tek isolate'te (tek iş parçacığında) çalıştığını öğrenmiştik. Peki, tek bir iş parçacığı varsa, Future'lar nasıl "aynı anda" birden fazla işi yönetiyormuş gibi görünüyor? Cevap: event loop (olay döngüsü) mekanizması.

Zihinsel model: Dart'ın çalışma zamanı, sürekli dönen bir döngüdür — bu döngü, sırayla şunları kontrol eder: "yapılacak bir iş var mı? Varsa yap. Yoksa bekle." Future'lar, bu döngüye "ileride yapılacak işler" olarak eklenir.

#İki Kuyruk: Microtask Queue ve Event Queue

Dart'ın event loop'u, iki ayrı kuyruk (queue) kullanır:

1. Microtask Queue: Küçük, dahili işler için (genelde Future sonuçlarının işlenmesi).
2. Event Queue: Daha "büyük" dış olaylar için (I/O tamamlanması, zamanlayıcılar — Timer, kullanıcı girdileri).

Kritik kural: Microtask queue, event queue'dan HER ZAMAN önce boşaltılır.

void main() {
  print('1. Senkron kod');

  Future(() => print('4. Event queue (Future ile eklendi)'));

  Future.microtask(() => print('3. Microtask queue'));

  print('2. Senkron kod (devam)');
}

Çıktı:

1. Senkron kod
2. Senkron kod (devam)
3. Microtask queue
4. Event queue (Future ile eklendi)

Bunu adım adım açıklayalım:

1. Program, önce tüm senkron kodu çalıştırır (1. ve 2. satırları) — event loop, senkron kod çalışırken hiçbir şeye dokunmaz.
2. Senkron kod bittiğinde, event loop önce microtask queue'yu tamamen boşaltır (3.).
3. Microtask queue tamamen boşaldıktan sonra, event queue'dan bir sonraki işi alır (4.).

#await Aslında Ne Yapıyor?

Bölüm 10'da await'in "Future'ı bekler" dediğimizi hatırlarsan, şimdi bunun tam mekaniğini görelim:

void main() async {
  print('1');
  await Future(() => print('bu bir future'));
  print('3'); // bu satır, future TAMAMLANDIKTAN sonra çalışır
}

await ile karşılaşıldığında, Dart şunu yapar: fonksiyonun geri kalanını (o satırdan sonraki her şeyi), bir microtask olarak "kaydeder" ve o Future tamamlanana kadar bu fonksiyonun çalışmasını duraklatır — ama bu, programın tamamının durması anlamına gelmez! Diğer senkron kod (varsa) ve diğer bekleyen işler, bu sırada çalışmaya devam edebilir.

#Bir Future Zincirinde Hata Yayılımı — Tam Mekanik

Bölüm 8'de try/catch'i, Bölüm 10'da bunun asenkron kodla birlikte kullanımını öğrenmiştik. Şimdi bir hatanın, bir Future zincirinde tam olarak nasıl "yayıldığını" görelim:

Future<int> adim1() async {
  print("Adım 1 çalışıyor");
  throw Exception("Adım 1'de hata!");
}

Future<int> adim2() async {
  print("Adım 2 çalışıyor"); // Bu satır HİÇ çalışmaz
  return 42;
}

void main() async {
  try {
    int sonuc1 = await adim1(); // hata burada fırlatılır
    int sonuc2 = await adim2(); // BU SATIRA HİÇ ULAŞILMAZ
    print("Sonuç: $sonuc2");
  } catch (e) {
    print("Hata yakalandı: $e");
  }
}

Çıktı:

Adım 1 çalışıyor
Hata yakalandı: Exception: Adım 1'de hata!

Mekanik olarak ne oluyor? adim1() içindeki throw, o Future'ı "hata durumunda tamamlanmış" (completed with error) olarak işaretler. await adim1() satırı, bu hatayı yakalar ve o anda fırlatır — tıpkı senkron bir throw gibi davranır. Bu, try/catch bloğunun onu doğal olarak yakalamasını sağlar. adim2()'ye hiç ulaşılmaz çünkü Dart, await satırında hata görür görmez, o try bloğunun geri kalanını atlayıp doğrudan catch'e geçer — tıpkı Bölüm 8'de öğrendiğimiz senkron throw davranışı gibi.

#Yakalanmayan Bir Hata — Ne Olur?

Future<int> riskliIslem() async {
  throw Exception("Yakalanmayan hata");
}

void main() async {
  int sonuc = await riskliIslem(); // try/catch YOK!
  print(sonuc); // bu satıra hiç ulaşılmaz
}

Bu durumda, hata yakalanmadan üst katmanlara "yayılmaya" devam eder — eğer main()'in kendisi de bunu yakalamıyorsa, program bir "Unhandled exception" hatasıyla çöker. Bu, Bölüm 8'de öğrendiğimiz "hata, en yakın uygun try/catch'e kadar yukarı doğru yayılır" prensibinin, asenkron Future zincirlerinde de birebir aynı şekilde işlediğini gösteriyor.

#Future.then() Zincirinde Hata Yayılımı

Bölüm 10 Konu 46'da öğrendiğimiz .then() zincirlerinde de aynı mantık geçerlidir:

void main() {
  Future(() => throw Exception("Hata!"))
      .then((veri) => print("Bu ÇALIŞMAZ: $veri"))
      .then((veri) => print("Bu da ÇALIŞMAZ"))
      .catchError((hata) => print("Yakalandı: $hata"));
}

Bir .then() zincirinde hata oluştuğunda, zincirdeki sonraki tüm .then() blokları atlanır ve kontrol doğrudan en yakın .catchError()'a (veya zincirde bir .then()'in onError parametresine) geçer — tıpkı try/catch'te olduğu gibi.

#Neden Bu Mekaniği Bilmek Önemli? — Pratik Sonuçlar

1. Debugging (hata ayıklama) kolaylaşır: Bir asenkron kod parçası beklenmedik sırada çalışıyorsa (örneğin bir print'in "olması gerekenden" önce/sonra çıktığını görüyorsan), microtask/event queue mantığını bilmek, neden böyle olduğunu anlamana yardımcı olur.

2. Performans sorunlarını anlama: Çok sayıda microtask, event queue'nun (kullanıcı etkileşimleri, zamanlayıcılar gibi) gecikmesine yol açabilir — çünkü microtask queue tamamen boşalana kadar event queue'ya sıra gelmez. Bu, Flutter'da UI'ın "tepkisiz" görünmesine yol açabilecek senaryoları anlamak için önemlidir.

3. Hata yönetimi tasarımı: Bir Future zincirinde nereye try/catch veya .catchError() koyman gerektiğine karar verirken, hatanın tam olarak nasıl yayılacağını bilmek, doğru yerde yakalamanı sağlar.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Dart'ın event loop'u, senkron kodu önce çalıştırır, sonra microtask queue'yu tamamen boşaltır, sonra event queue'dan bir iş alır — bu sıra kesindir.
• await, fonksiyonun geri kalanını bir microtask olarak zamanlar ve o Future tamamlanana kadar (programın tamamını değil, sadece o fonksiyonu) duraklatır.
• Bir Future zincirinde (async/await veya .then ile) oluşan hata, senkron throw gibi davranır — en yakın try/catch veya .catchError()'a kadar sonraki adımları atlayarak yayılır.
• Yakalanmayan bir asenkron hata, programın "Unhandled exception" ile çökmesine yol açar.
• Bu mekaniği bilmek, asenkron kodun çalışma sırasını tahmin etmeni, performans sorunlarını anlamanı ve hata yönetimini doğru tasarlamanı sağlar.

#📝 Ödevler

• [ ] Future ve Future.microtask ile senkron print çağrılarını karışık sırada yazıp, çalıştırmadan önce çıktı sırasını tahmin et; sonra çalıştırıp doğrula.
• [ ] await kullanan iki adımlı bir asenkron fonksiyonda, ilk adımda throw ile hata fırlat, ikinci adımın hiç çalışmadığını print ile kanıtla.
• [ ] .then() zincirinde bir hata oluştur, zincirdeki sonraki .then() bloklarının atlandığını, .catchError()'ın çalıştığını göster.
• [ ] Yakalanmayan bir asenkron hata örneği yaz (try/catch olmadan), "Unhandled exception" davranışını gözlemle.
• [ ] Kendi cümlelerinle, "microtask queue neden her zaman event queue'dan önce boşaltılır" sorusunu, bu dersten öğrendiklerinle açıkla.

Sıradaki konu: Bölüm 13 — Konu 62: Memory Model & Performans — Garbage Collection, const Nesnelerin Bellek Avantajı