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

#Bellek Yönetimi Neden Önemli?

Bölüm 1'de, Flutter'ın Dart'ı seçme sebeplerinden biri olarak "UI-dostu garbage collection"dan bahsetmiştik. Şimdi bu ifadenin tam olarak ne anlama geldiğini işleyeceğiz.

#Bellekte Nesneler Nasıl Saklanır? — Kısa Bir Zihinsel Model

Bir program çalışırken, oluşturduğun her nesne (Bölüm 6'da öğrendiğimiz class örnekleri, listeler, string'ler) bellekte (RAM'de) bir yer kaplar. Bu bellek alanına genelde heap (yığın) denir. Bir nesne oluşturduğunda, Dart runtime'ı heap'te ona yer ayırır; nesne artık kullanılmadığında, o bellek alanının boşaltılması (serbest bırakılması) gerekir — aksi halde bellek dolar ve program çöker (buna "memory leak" — bellek sızıntısı denir).

#Garbage Collection (Çöp Toplama) Nedir?

C gibi bazı dillerde, belleği elle yönetmen gerekir — bir nesneyi oluşturur, işin bitince sen onu serbest bırakırsın. Bu, hataya çok açık bir süreçtir (unutulan bir serbest bırakma, bellek sızıntısına; erken bırakılan bir bellek, çökmeye yol açabilir).

Dart (Java, Python, JavaScript gibi birçok modern dil gibi), garbage collection (GC) kullanır — bu, artık kullanılmayan nesneleri otomatik olarak tespit edip belleği geri kazanan bir mekanizmadır. Sen elle bellek yönetmezsin; Dart runtime'ı, arka planda periyodik olarak çalışan bir "çöp toplayıcı" ile bunu senin için yapar.

void ornekFonksiyon() {
  List<int> gecici = [1, 2, 3, 4, 5]; // heap'te yer ayrılır
  print(gecici.length);
} // fonksiyon bitince, 'gecici' artık erişilemez -> GC tarafından temizlenmeye ADAY olur

void main() {
  ornekFonksiyon();
  // 'gecici' listesi artık hiçbir yerden erişilemiyor, GC bir noktada bu belleği geri kazanır
}

#Dart'ın Generational (Nesiller Arası) Garbage Collector'ı

Dart'ın GC'si, generational (nesillere dayalı) bir stratejiyle çalışır — bu, gerçek dünya gözleminden gelen bir optimizasyondur: çoğu nesne, çok kısa ömürlüdür (bir fonksiyon içinde oluşturulup hemen kullanılıp atılır), az sayıda nesne ise uzun süre yaşar (örneğin uygulamanın ana state'i).

Bu gözleme dayanarak, Dart'ın çöp toplayıcısı belleği iki bölgeye ayırır:

1. Young generation (genç nesil / "new space"): Yeni oluşturulan nesneler buraya konur. Bu bölge sık sık ve çok hızlı taranır — çünkü buradaki nesnelerin çoğu kısa ömürlüdür, hızlıca "çöp" haline gelir.
2. Old generation (eski nesil / "old space"): Young generation'da birkaç tarama sürecinden hayatta kalan (hâlâ kullanılan) nesneler buraya "terfi eder." Bu bölge, daha az sıklıkla taranır çünkü buradaki nesnelerin uzun süre yaşayacağı varsayılır.

Bu neden "UI-dostu"dur? Çünkü young generation taramaları (en sık yapılan tarama türü) çok hızlıdır ve genelde milisaniyelerin altında tamamlanır — bu, Flutter'ın her saniye onlarca kez ekranı yeniden çizmesi (widget'ları yeniden oluşturması) gerektiğinde, GC'nin UI'ı fark edilir şekilde durdurmamasını sağlar. Eğer GC, her taramada tüm belleği kontrol etseydi, bu "jank" (takılma) yaratabilirdi.

#const Nesnelerin Bellek Avantajı — Bölüm 2 ve Bölüm 6'ya Geri Dönüş

Bölüm 2'de const'un "derleme zamanında sabit" anlamına geldiğini öğrenmiştik. Şimdi bunun bellek üzerindeki gerçek etkisini görelim:

class Nokta {
  final double x;
  final double y;
  const Nokta(this.x, this.y); // const constructor
}

void main() {
  var n1 = const Nokta(1, 2);
  var n2 = const Nokta(1, 2);

  print(identical(n1, n2)); // true — AYNI bellek adresini işaret ediyorlar!
}

identical(), iki değişkenin tam olarak aynı nesneyi (bellekte aynı adresi) işaret edip etmediğini kontrol eder. const Nokta(1, 2) iki kere yazılmasına rağmen, Dart bunları tek bir nesne olarak "birleştiriyor" (deduplication/canonicalization) — çünkü const nesneler değişmezdir (immutable), bu yüzden aynı değerlere sahip iki const nesne, güvenle aynı bellek konumunu paylaşabilir.

Karşılaştıralım — const olmadan:

class Nokta {
  final double x;
  final double y;
  Nokta(this.x, this.y); // const OLMAYAN constructor
}

void main() {
  var n1 = Nokta(1, 2);
  var n2 = Nokta(1, 2);

  print(identical(n1, n2)); // false — İKİ AYRI nesne, iki ayrı bellek alanı
}

Burada, her Nokta(1, 2) çağrısı yeni bir nesne oluşturur — iki ayrı bellek alanı kullanılır, ikisi de ayrı ayrı GC tarafından takip edilmesi gerekir.

#Neden Bu, Performans Açısından Önemli?

1. Daha az bellek kullanımı: Aynı const değer, kodun her yerinde tekrar tekrar kullanılıyorsa (örneğin bir renk sabiti, bir boşluk değeri), her kullanımda yeni bir nesne oluşturmak yerine, tek bir paylaşılan nesne kullanılır.

2. Daha az GC yükü: Daha az nesne oluşturulduğu için, garbage collector'ın taraması gereken nesne sayısı azalır — bu, Bölüm 13'te öğrendiğimiz young generation taramalarının daha hızlı olmasına katkıda bulunur.

3. Flutter'da doğrudan performans etkisi: Flutter'da bir widget'ı const olarak işaretlediğinde (const Text("Merhaba") gibi — bunu Flutter tutorial'ında detaylı göreceğiz), Flutter bu widget'ın hiç değişmeyeceğini bilir ve onu yeniden oluşturmaktan (rebuild) tamamen kaçınabilir. Bu, Flutter'ın performans optimizasyonlarının en temel ve en etkili yöntemlerinden biridir — ve şimdi öğrendiğin bellek modeli sayesinde, neden bu kadar etkili olduğunu anlıyorsun.

#Değişmezlik (Immutability) ile Bellek Verimliliği Arasındaki İlişki

Bu derste öğrendiğin şey, aslında daha genel bir prensibin somut bir örneği: değişmez (immutable) veri yapıları, paylaşılabilir (shareable) oldukları için bellek açısından daha verimlidir. Bölüm 2'de final/const'u öğrenirken "kodun okunabilirliği ve güvenliği için" demiştik — şimdi buna performans boyutunu da ekliyoruz. Bu, Dart'ın (ve Flutter'ın) neden "mümkün olduğunca const kullan" tavsiyesini bu kadar sık verdiğinin teknik temelidir.

#hashCode ve == ile İlişki — Kısa Bir Not

identical()'ın kontrol ettiği "aynı bellek adresi", Bölüm 6'da gördüğümüz == operatöründen farklıdır — ==, varsayılan olarak (override edilmediği sürece) identical() ile aynı davranır, ama bir class kendi == operatörünü override ederse (örneğin "içerik eşitse eşit say" mantığıyla), iki farklı bellek adresindeki nesne == ile eşit sayılabilir, identical() ile sayılamaz. Bu, ileri bir detay — şimdilik identical()'ın gerçek bellek adresini kontrol ettiğini, =='nin ise class'ın tanımladığı eşitlik mantığını kullandığını bilmen yeterli.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Garbage collection, artık kullanılmayan nesnelerin belleğini otomatik olarak geri kazanan bir mekanizmadır; Dart'ta elle bellek yönetimi gerekmez.
• Dart'ın GC'si "generational"dır — kısa ömürlü nesneler (young generation) sık ve hızlı, uzun ömürlü nesneler (old generation) daha seyrek taranır; bu, UI-dostu performans sağlar.
• const nesneler, aynı değerlere sahip olduklarında tek bir bellek konumunu paylaşır (identical() ile doğrulanabilir) — bu, daha az bellek kullanımı ve daha az GC yükü sağlar.
• Flutter'da const widget'lar, gereksiz yeniden oluşturmadan (rebuild) tamamen kaçınılmasını sağlayarak doğrudan performans katkısı sunar.
• Değişmezlik (immutability), paylaşılabilirlik sayesinde bellek verimliliğine katkıda bulunan genel bir prensiptir.

#📝 Ödevler

• [ ] const bir constructor'lı bir sınıf yaz, aynı değerlerle iki const nesne oluştur, identical() ile aynı bellek adresini paylaştıklarını kanıtla.
• [ ] Aynı sınıfı const olmadan iki kere oluştur, identical() ile bu sefer farklı nesneler olduklarını göster.
• [ ] Kendi cümlelerinle, "neden const nesneler paylaşılabilir ama normal nesneler paylaşılamaz" sorusunu, değişmezlik kavramıyla ilişkilendirerek açıkla.
• [ ] Generational garbage collection'ın "young generation" ve "old generation" ayrımını, kendi örneğinle (örn. bir döngü içinde oluşturulan geçici değişkenler vs uygulamanın ana state'i) açıkla.
• [ ] Kendi cümlelerinle, "Flutter'da const widget kullanmanın performans üzerindeki etkisi nedir" sorusunu, bu derste öğrendiğin bellek modeliyle bağlantı kurarak yanıtla.

Sıradaki konu: Bölüm 13 — Konu 63: Isolate'ler Arası Mesajlaşmanın Maliyeti ve compute() Fonksiyonunun İç İşleyişi