Stack, Heap ve Pass-by-Value

Bir metoda nesne verdin, metot onu değiştirdi ve değişikliği sen de gördün. “Demek ki nesnenin kendisini verdim” demek çok doğal, ama yanlış: Java her zaman bir kopya verir.

Stack ve heap

Stack?Terimin tanımını açstackHer thread'in kendine ait, metot çağrılarının üst üste yığıldığı bellek alanı. Metot bitince o kare otomatik silinir.Stack üzerinde yerel değişkenler ve referanslar durur. Boyutu sabittir; sonsuz özyineleme burayı doldurunca StackOverflowError alırsın.Sözlükte gör →, her metot çağrısı için bir frame açar. İçinde yerel değişkenler durur ve metot dönünce frame tamamen yok olur.

Heap?Terimin tanımını açheapTüm thread'lerin paylaştığı, `new` ile üretilen nesnelerin yaşadığı bellek alanı. Temizliğini garbage collector yapar.Sözlükte gör → ise bütün nesnelerin yaşadığı, bütün thread’lerin paylaştığı alandır.

Kritik ayrım: ilkel tipler değerleriyle stack’te durur, nesneler heap’tedir ve stack yalnızca adreslerini tutar.

1
int x = 5;                    // stack: x = 5
2
User u = new User("ali");     // stack: u = @1    heap: @1 → User{name:"ali"}

Satır satır: kopyalanan ne?

Aşağıdaki metot üç şey yapıyor ve üçü de aynı kuralın farklı yüzleri.

Üçü de aynı kuralın sonucu: değer kopyalanır. İlkel tipte kopyalanan sayı, referansta?Terimin tanımını açreferenceBir nesnenin heap'teki adresini tutan değer. Java'da değişkenler nesneyi değil, nesneye giden referansı tutar.Sözlükte gör → kopyalanan adrestir.

Aşağıdaki küçük banka programı dersteki üç durumu yan yana çalıştırıyor: referansı yeniden atamak, hesabı değiştirmek ve değiştirilemez bir tutar.

1
public class Account {
2

3
    private final String owner;
4
    private BigDecimal balance;         // mutable state on the heap
5

6
    public Account(String owner, BigDecimal balance) {
7
        this.owner = owner;
8
        this.balance = balance;
9
    }
10

11
    public void credit(BigDecimal amount) {
12
        balance = balance.add(amount);
13
    }
14

15
    @Override
16
    public String toString() {
17
        return owner + ":" + balance;
18
    }
19
}

1
// Immutable: "changing" it means creating a new one.
2
public record Money(BigDecimal amount, String currency) {
3

4
    public Money plus(BigDecimal more) {
5
        return new Money(amount.add(more), currency);
6
    }
7
}

1
public final class Transfers {
2

3
    private static final BigDecimal EFT_FEE = new BigDecimal("5.00");
4

5
    private Transfers() {}
6

7
    // The parameter is a COPY of the caller's reference. Pointing the copy
8
    // at a new object leaves the caller's variable untouched.
9
    static void replace(Account account) {
10
        account = new Account("mallory", new BigDecimal("1000000.00"));
11
    }
12

13
    // Both copies point to the same heap object: the change is visible to the caller.
14
    static void receiveTransfer(Account account) {
15
        account.credit(new BigDecimal("50.00"));
16
    }
17

18
    // Records cannot be changed; plus() returns a new object that the caller never sees
19
    // unless it is returned.
20
    static Money addFee(Money money) {
21
        money.plus(EFT_FEE);            // result ignored: nothing happens
22
        return money.plus(EFT_FEE);     // the only way to hand back the new value
23
    }
24
}

1
public class Main {
2

3
    public static void main(String[] args) {
4
        Account alice = new Account("alice", new BigDecimal("100.00"));
5

6
        Transfers.replace(alice);
7
        System.out.println(alice);            // alice:100.00  — reassignment did not escape
8

9
        Transfers.receiveTransfer(alice);
10
        System.out.println(alice);            // alice:150.00  — mutation did
11

12
        Money amount = new Money(new BigDecimal("20.00"), "TRY");
13
        Money withFee = Transfers.addFee(amount);
14
        System.out.println(amount);           // Money[amount=20.00, currency=TRY]
15
        System.out.println(withFee);          // Money[amount=25.00, currency=TRY]
16

17
        int count = 1;
18
        increment(count);
19
        System.out.println(count);            // 1 — primitives are copied too
20
    }
21

22
    static void increment(int value) {
23
        value++;
24
    }
25
}

Gerçek pass-by-reference?Terimin tanımını açpass-by-valueJava metoda her zaman değerin kopyasını geçer. Nesnelerde kopyalanan şey nesne değil, referanstır — bu yüzden nesnenin içi değişir ama değişkenin gösterdiği yer değişmez.Sözlükte gör → olsaydı, user = new User("zeynep") satırı main’deki u’yu da değiştirirdi. Değiştirmiyor — ve Java’da swap(a, b) yazılamamasının sebebi tam olarak bu.

Kendin gör

Simülatör satır satır ilerliyor. Solda stack frame’leri, sağda heap nesneleri.

1. Adımla ve main frame’ine bak. modify içindeki n = 99 çalıştıktan sonra bile x hâlâ 5.
2. setName satırına gel. Bu kez sağdaki heap nesnesinin içeriği değişiyor — çünkü iki frame de aynı nesneyi gösteriyor.
3. Son atamayı geç. Yeni nesne sağda beliriyor ama main’deki ok hiç oynamıyor.
4. Görevleri tamamla. Simülatörün altındaki üç görev seni üç senaryoda da doğru ana götürüyor.

Çöpü kim, neye bakarak topluyor?

Senaryoyu Erişilebilirlik olarak değiştir ve adımla. Önce aşağıdaki sahne bütün fikri tek seferde gösteriyor.

Java’nın çöp toplayıcısı “bu nesneyi kaç kişi gösteriyor?” diye saymaz. Sabit başlangıç noktalarından (kökler) yola çıkar ve ulaşabildiği her nesneyi işaretler.

Bir nesneye hiçbir kökten ulaşılamıyorsa toplanabilir hâle gelir.

Referans sayma yerine erişilebilirlik kullanmanın önemli bir sonucu var: döngüsel referanslar Java’da sızıntı yapmaz. Birbirini gösteren iki nesneye dışarıdan ulaşılamıyorsa ikisi de çöptür.

Gerçek sızıntılar erişilebilirlikten gelir — hâlâ ulaşılabilen ama bir daha kullanılmayacak nesnelerden:

1
// static bir koleksiyon asla temizlenmezse, içindeki her şey sonsuza dek erişilebilir
2
private static final Map<String, Session> SESSIONS = new HashMap<>();

Tuzaklar

String pool. String literal’leri JVM’in havuzunda saklanır ve aynı literal her yerde aynı nesneyi verir.

1
String a = "merhaba";
2
String b = "merhaba";
3
String c = new String("merhaba");
4

5
a == b;          // true  — ikisi de pool'daki aynı nesne
6
a == c;          // false — new String pool'u atladı, ayrı nesne
7
a.equals(c);     // true  — içerik aynı

new String("...") neredeyse hiçbir zaman gerekmez; tek etkisi pool’u atlayıp gereksiz bir nesne üretmektir.

İki hata, iki bölge. StackOverflowError ile OutOfMemoryError farklı yerlerden gelir:

OutOfMemoryError genellikle “heap küçük” demek değildir; “bir şey bırakılmıyor” demektir. Önce heap dump alıp neyin biriktiğine bakılır, sonra -Xmx düşünülür.

Kendini sına

Önce hızlı bir ısınma: puan yok, kayıt yok. Sonra asıl sorular.