Go'da Garbage Collection

Coddy'nin GO Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası — ders 23 / 107.

C veya C++ gibi dillerin aksine Go, bellek yönetimini çöp toplama (garbage collection - GC) aracılığıyla otomatik olarak gerçekleştirir. İşiniz bittiğinde belleği manuel olarak boşaltmanıza gerek yoktur. Go çalışma zamanı (runtime), hangi belleğin hala kullanımda olduğunu takip eder ve geri kalanını geri kazanır.

new(), make() kullanarak veya değişkenler oluşturarak bellek tahsis ettiğinizde, Go'nun çöp toplayıcısı (garbage collector) bu tahsisleri izler. Bir değere programınızın herhangi bir bölümünden artık erişilemediğinde, GC bu belleği otomatik olarak serbest bırakır.

func createPerson() *Person {
    p := &Person{Name: "Alice", Age: 30}
    return p  // p heap'e çıkar, GC onu yönetecektir
}

func main() {
    person := createPerson()
    fmt.Println(person.Name)
    // person artık kullanılmadığında, GC belleği geri kazanır
}

Bu örnekte, Person yapısı fonksiyondan döndürüldüğü için heap üzerinde tahsis edilir. Go derleyicisi, bir değişkenin stack'te mi kalabileceğini yoksa heap'e mi taşınması gerektiğini belirlemek için kaçış analizi (escape analysis) gerçekleştirir. Çöp toplayıcı (garbage collector) yalnızca heap belleğini yönetir.

Bu otomatik bellek yönetimi, unutulan bellek boşaltma işlemlerinden kaynaklanan bellek sızıntıları hakkında endişelenmeden uygulamanızı oluşturmaya odaklanabileceğiniz anlamına gelir. Ancak, GC'nin var olduğunu anlamak, performansın önemli olduğu durumlarda gereksiz tahsisleri en aza indirerek daha verimli kod yazmanıza yardımcı olur.

Görev

Kolay

Go'nin çöp toplayıcısının (garbage collector) yığına (heap) sızan nesneler için belleği nasıl yönettiğini gösteren bir oturum yöneticisi oluşturalım. Dinamik olarak tahsis edilen ve fonksiyonlardan döndürülen oturumlar oluşturacaksınız, böylece yaşam döngülerini GC'nin yönetmesine izin vereceksiniz.

Kodunuzu iki dosya halinde düzenleyeceksiniz:

session.go: ID (string), Username (string) ve Data (string dilimi - slice) alanlarına sahip bir Session yapısı (struct) tanımlayın. Bir ID ve kullanıcı adı alan, yığında yeni bir Session tahsis eden (bir işaretçi - pointer döndürerek) ve Data dilimini boş olarak başlatan bir NewSession fonksiyonu oluşturun. Ayrıca, oturumun Data dilimine bir string ekleyen işaretçi alıcılı (pointer receiver) bir AddData metodu ve oturum ayrıntılarını gösteren biçimlendirilmiş bir string döndüren bir Summary metodu ekleyin.
main.go: Girişten oturum bilgilerini okuyun, yapıcı (constructor) fonksiyonunuzu kullanarak bir oturum oluşturun, ona bazı veri girişleri ekleyin ve oturum özetini görüntüleyin. Oturum bir fonksiyon içinde oluşturulup bir işaretçi olarak döndürüldüğü için, çöp toplayıcının onu yöneteceği yığına (heap) sızar.

Aşağıdaki girişler sağlanacaktır:

Satır 1: Session ID
Satır 2: Username
Satır 3: Eklenecek ilk veri girişi
Satır 4: Eklenecek ikinci veri girişi

Summary metodunuz şu formatta bir string döndürmelidir:

Session [ID] for user [Username]
Data entries: [count]
- [entry1]
- [entry2]

Örneğin, sess-001, alice, login ve view_dashboard verildiğinde, çıktınız şöyle olmalıdır:

Session sess-001 for user alice
Data entries: 2
- login
- view_dashboard

Buradaki temel nokta, NewSession fonksiyonunuzun bir Session oluşturması ve ona bir işaretçi döndürmesidir. Bu, Session'ın yığında (stack) kalmak yerine yığına (heap) "sızmasına" (escape) neden olur ve ona yönelik hiçbir referans kalmadığında çöp toplama için uygun hale gelir. Kodunuzun bu belleği manuel olarak serbest bırakması gerekmez; Go bunu otomatik olarak halleder.

Kopya kağıdı

Go, otomatik bellek yönetimi için çöp toplama (garbage collection - GC) kullanır. Belleği manuel olarak boşaltmanıza gerek yoktur.

Çöp toplayıcı, bellek tahsislerini izler ve programınız tarafından artık erişilemeyen belleği geri kazanır.

func createPerson() *Person {
    p := &Person{Name: "Alice", Age: 30}
    return p  // p yığına (heap) kaçar, GC onu yönetecektir
}

func main() {
    person := createPerson()
    fmt.Println(person.Name)
    // person artık kullanılmadığında, GC belleği geri kazanır
}

Go derleyicisi, bir değişkenin yığında (stack) mı kalacağını yoksa öbeğe (heap) mi taşınacağını belirlemek için kaçış analizi (escape analysis) gerçekleştirir. Öbeğe kaçan değişkenler (döndürülen işaretçiler gibi) çöp toplayıcı tarafından yönetilir.

GC yalnızca öbek (heap) belleğini yönetir, yığın (stack) belleğini yönetmez. Yığın belleği, bir fonksiyon döndüğünde otomatik olarak boşaltılır.

Kendin dene

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Oturum kimliğini oku
	sessionID, _ := reader.ReadString('\n')
	sessionID = sessionID[:len(sessionID)-1]

	// Kullanıcı adını oku
	username, _ := reader.ReadString('\n')
	username = username[:len(username)-1]

	// İlk veri girişini oku
	data1, _ := reader.ReadString('\n')
	data1 = data1[:len(data1)-1]

	// İkinci veri girişini oku
	data2, _ := reader.ReadString('\n')
	data2 = data2[:len(data2)-1]

	// TODO: NewSession fonksiyonunu kullanarak yeni bir oturum oluşturun
	// Bir pointer döndürdüğümüz için oturum heap'e çıkacaktır

	// TODO: AddData metodunu kullanarak veri girişlerini oturuma ekleyin

	// TODO: Summary metodunu kullanarak oturum özetini yazdırın
	fmt.Println("")
}