• Stack (Yığın): Fonksiyon çağrıları ve yerel değişkenler için kullanılan, son giren ilk çıkar (LIFO) prensibiyle çalışan bir bellek bölgesidir. Bellek tahsisatları hızlı ve deterministiktir. Bir fonksiyon sonlandığında, o fonksiyona ait stack frame otomatik olarak serbest bırakılır. Genellikle boyutu küçük, ömrü kısa ve derleme zamanında boyutu bilinen değerler stack üzerinde saklanır.
• Heap (Öbek): Dinamik bellek tahsisatı için kullanılan bölgedir. Ömrü, tahsis edildiği fonksiyonun ömründen daha uzun olabilecek veriler burada saklanır. Bellek tahsisatları stack'e göre daha yavaştır ve Çöp Toplayıcı tarafından yönetilir. Boyutu bilinmeyen veya çalışma zamanında değişebilen veri yapıları (örneğin, büyük slice'lar, map'ler, kanallar) genellikle heap üzerinde yer alır.

func createUser(name string) *User {
    user := User{Name: name} // 'user' bu örnekte heap'e kaçabilir
    return &user // Referans döndüğü için kaçış analizi burada devreye girer
}

func processData(data []byte) {
    buffer := make([]byte, 1024) // 'buffer' eğer dışarıya kaçmazsa stack'te kalabilir
    // ...
}

• Concurrent (Eşzamanlı): GC'nin çoğu işi (işaretleme aşaması gibi) uygulamanın goroutine'ları ile eşzamanlı olarak çalışır. Bu, uygulamanın çalışmaya devam etmesini ve duraklama (stop-the-world) sürelerinin minimumda tutulmasını sağlar.
• Non-generational (Jenerasyonsuz): Java veya .NET gibi bazı dillerdeki GC'lerden farklı olarak Go'nun GC'si, nesneleri yaşlarına göre farklı jenerasyonlara ayırmaz. Tüm erişilebilir nesneleri her döngüde tarar.
• Tri-color Mark-and-Sweep: Nesneleri beyaz (erişilemez, silinecek), gri (erişilebilir, henüz tarandı) ve siyah (erişilebilir, taranmış) olarak işaretler. Tarama tamamlandığında beyaz nesneler serbest bırakılır. Bir write barrier (yazma bariyeri) sayesinde GC çalışırken nesneler arasında referans değişiklikleri izlenebilir.

• Değer Tipleri: `int`, `float`, `bool`, `string`, `struct`'lar (eğer tüm alanları değer tipi ise) ve `array`'ler değer tipidir. Bu tipler bir fonksiyona parametre olarak geçirildiğinde veya bir değişkene atandığında, verinin tam bir kopyası oluşturulur. Büyük `struct`'ların veya `array`'lerin kopyalanması performansı olumsuz etkileyebilir ve ek bellek tahsisatlarına yol açabilir.
• Referans Tipleri: `slice`, `map`, `channel`, `pointer` ve `interface`'ler referans tipidir. Bu tipler aslında temeldeki veri yapısına (genellikle heap'te saklanan) bir referans tutar. Bir fonksiyona geçirildiklerinde, sadece referansın kendisi kopyalanır, tüm veri kopyalanmaz. Bu, özellikle büyük veri yapılarıyla çalışırken daha verimlidir.

"Verimli bellek yönetimi, sadece çöp toplayıcının işini kolaylaştırmakla kalmaz, aynı zamanda uygulamanızın genel performansını da artırır."

Genişletmek için tıkla ...

• Slice Kapasitesi Sorunları: Bir slice'ın küçük bir bölümünü alıp (re-slice) kullanmaya devam ettiğinizde, orijinal büyük slice'ın altında yatan dizi hala bellekte tutulabilir. Bu, kullanılmayan büyük bir belleğin GC tarafından temizlenemesine neden olabilir. Çözüm olarak, `copy` fonksiyonunu kullanarak yeni, daha küçük bir diziye veri kopyalamak veya `nil` atayarak referansı koparmak etkili olabilir.
  
  Kod:

  func getSmallSlice(bigSlice []int) []int {
      // Bu, bigSlice'ın underlying array'ini bellekte tutmaya devam eder
      // return bigSlice[100:110]
  
      // Doğru yaklaşım: yeni bir slice'a kopyala
      smallSlice := make([]int, 10, 10)
      copy(smallSlice, bigSlice[100:110])
      return smallSlice
  }

• Kapanışların (Closures) Değişken Yakalaması: Bir kapanış, dış kapsamdaki değişkenleri yakaladığında, bu değişkenlerin ömrünü uzatabilir ve heap'e kaçmasına neden olabilir. Özellikle döngüler içinde kapanışlar oluşturulurken dikkatli olunmalıdır.
• Süresiz Büyüyen Veri Yapıları: `map` veya `slice` gibi veri yapıları sürekli olarak veri eklenip temizlenmediğinde bellekte sürekli büyüyebilir. Kullanılmayan girdileri düzenli olarak temizlemek veya sınırlandırmak önemlidir.
• Goroutine Sızıntıları: Bir goroutine başlatılır ve hiçbir zaman sonlanmazsa (örneğin, bir kanal üzerinden mesaj beklemeye devam ediyorsa ve kanal hiçbir zaman kapatılmıyorsa veya mesaj gelmiyorsa), o goroutine'un stack'i ve referans tuttuğu tüm veriler bellekte kalır. Bu durum, ciddi bellek sızıntılarına yol açabilir.

• Tahsisatları Azaltma: Her bellek tahsisatı (özellikle heap'e) bir maliyet getirir. Yeni nesneler oluşturmak yerine mevcut nesneleri veya buffer'ları yeniden kullanmaya çalışın. `sync.Pool` bu tür senaryolar için harika bir araçtır. Özellikle sıkça kullanılan ve kısa ömürlü nesneler için nesne havuzlama (object pooling) stratejileri düşünülebilir.
  sync.Pool dokümantasyonu için tıklayın.
  
• Ön-Tahsisat (Pre-allocation): Eğer bir slice'ın veya map'in nihai boyutunu tahmin edebiliyorsanız, `make` fonksiyonunu kullanarak yeterli kapasiteyi önceden tahsis edin. Bu, yeniden tahsisatların (reallocations) ve buna bağlı GC maliyetlerinin önüne geçer.
  
  Kod:

  // Kötü:
  var mySlice []int
  for i := 0; i < 1000; i++ {
      mySlice = append(mySlice, i)
  }
  
  // İyi:
  mySlice := make([]int, 0, 1000) // 1000 elemanlık kapasite ile başla
  for i := 0; i < 1000; i++ {
      mySlice = append(mySlice, i)
  }

• Veri Yapılarını Yeniden Kullanma: Özellikle RPC çağrıları veya ağ protokolleri gibi tekrarlayan işlemlerde, buffer'ları yeniden kullanmak tahsisatları önemli ölçüde azaltabilir. `bytes.Buffer` gibi tiplerin `Reset()` metotlarını kullanmak faydalıdır.
  
• Değer Tiplerini Akıllıca Kullanma: Küçük `struct`'lar veya `array`'ler için değer semantiği kullanmak, heap tahsisatlarından kaçınarak stack'te kalmalarını sağlayabilir. Ancak çok büyük değer tiplerini fonksiyon parametresi olarak kopyalamaktan kaçının; bu durumlarda pointer kullanmak daha verimli olabilir.
  
• Yapı (Struct) Alan Sırası ve Hizalama: Struct alanlarının sırası, bellekteki hizalamayı (padding) etkileyebilir. Benzer boyutlu alanları bir arada tutmak, struct'ın toplam bellek ayak izini azaltabilir. `go tool vet -composites` komutu bu konuda yardımcı olabilir.
  
• Bellek Profili Oluşturma (Profiling): Go, uygulamanızın bellek kullanımını analiz etmek için güçlü araçlar sunar. `net/http/pprof` paketi ve `go tool pprof` komutu ile canlı uygulamanızın heap ve CPU profillerini alabilir, bellek sızıntılarını veya yoğun tahsisat alanlarını tespit edebilirsiniz. Profilleme, bellek darboğazlarını bulmanın en etkili yoludur.
  
  Kod:

  // pprof'u etkinleştirmek için ana fonksiyonunuzda:
  // import _ "net/http/pprof"
  // go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()
  
  // Sonra terminalden:
  // go tool pprof http://localhost:6060/debug/pprof/heap

  
  Profili analiz ederken, özellikle `%inuse_space` ve `%inuse_objects` gibi metrikleri inceleyerek en çok belleği tüketen veya GC tarafından en çok işlenen alanları belirleyebilirsiniz.