1// Ornek1: Garbage Collection (çöp toplama) — bellek kullanımı ve WeakReference.
2// Çalıştırma: java Ornek1.java
3import java.lang.ref.WeakReference;
4import java.util.ArrayList;
5import java.util.List;
6
7public class Ornek1 {
8
9    public static void main(String[] args) {
10        Runtime rt = Runtime.getRuntime();
11        System.out.println("Maks bellek : " + mb(rt.maxMemory()) + " MB");
12        System.out.println("Başlangıç kullanılan: " + mb(kullanilan(rt)) + " MB");
13
14        // Çok sayıda nesne üret (çöp olacaklar). GC bunları toplayacak.
15        List<byte[]> tutucu = new ArrayList<>();
16        for (int i = 0; i < 100; i++) tutucu.add(new byte[100_000]); // ~10 MB
17        System.out.println("100 blok sonrası   : " + mb(kullanilan(rt)) + " MB");
18
19        tutucu.clear();        // referanslar gitti -> nesneler ARTIK ULAŞILAMAZ (çöp)
20        System.gc();           // GC ÖNERİSİ (garanti değil)
21        uyu(100);
22        System.out.println("clear + gc sonrası : " + mb(kullanilan(rt)) + " MB (GC topladı)");
23
24        // WeakReference: zayıf referans. Nesneye SADECE weak referans kalırsa GC onu toplayabilir.
25        Object nesne = new Object();
26        WeakReference<Object> zayif = new WeakReference<>(nesne);
27        System.out.println("\nweak.get() (güçlü ref varken): " + (zayif.get() != null ? "var" : "null"));
28        nesne = null;          // güçlü referansı kaldır -> yalnızca weak kaldı
29        System.gc();
30        uyu(100);
31        System.out.println("weak.get() (güçlü ref yokken): " + (zayif.get() != null ? "var" : "null (GC topladı)"));
32
33        System.out.println("""
34
35                --- Garbage Collection (çöp toplama) ---
36                Java'da belleği SEN yönetmezsin (C/C++ gibi free yok); ULAŞILAMAYAN nesneleri GC otomatik toplar.
37                Bir nesneye hiçbir güçlü referans kalmadığında çöptür ve GC onu temizleyebilir.
38                System.gc() yalnızca ÖNERİDİR (ne zaman/topkanacağı garanti değil); üretimde elle çağırma.
39                WeakReference: 'varsa kullan, GC alırsa sorun değil' (önbellekler). SoftReference: bellek baskısında atılır.
40                GC türleri: G1 (varsayılan), ZGC/Shenandoah (düşük gecikme - topic 20). Bellek sızıntısı = istemeden
41                tutulan referanslar (statik koleksiyonlar, kapanmayan kaynaklar).""");
42    }
43
44    static long kullanilan(Runtime rt) { return rt.totalMemory() - rt.freeMemory(); }
45    static long mb(long b) { return b / (1024 * 1024); }
46    static void uyu(long ms) { try { Thread.sleep(ms); } catch (InterruptedException ignored) {} }
47}

1// Ornek2: JIT derleyici — "ısınma" (warmup) ve neden elle mikro-benchmark GÜVENİLMEZ.
2// Çalıştırma: java Ornek2.java
3public class Ornek2 {
4
5    // Sıcak (hot) metot: çok çağrılınca JIT bunu yerel makine koduna derler.
6    static long hesapla(int n) {
7        long toplam = 0;
8        for (int i = 0; i < n; i++) toplam += (i * 31L) ^ (i >> 2);
9        return toplam;
10    }
11
12    public static void main(String[] args) {
13        int N = 2_000_000;
14        long kontrol = 0;
15
16        // Aynı işi arka arkaya birkaç tur ölç. İLK turlar genelde yavaştır (kod yorumlanıyor,
17        // JIT henüz derlememiş); sonraki turlar JIT derlemesi + önbellek ile genelde hızlanır.
18        // ANCAK sayılar tura/makineye göre DEĞİŞİR ve gürültülüdür — asıl ders budur.
19        System.out.println("Tur tur çalıştırma süreleri (µs):");
20        long[] sureler = new long[8];
21        for (int tur = 0; tur < sureler.length; tur++) {
22            long t0 = System.nanoTime();
23            kontrol += hesapla(N);
24            sureler[tur] = (System.nanoTime() - t0) / 1_000;
25            System.out.printf("  tur %d: ~%5d µs%n", tur + 1, sureler[tur]);
26        }
27
28        System.out.println("(kontrol toplamı kullanıldı: " + (kontrol != 0) + ")");
29        System.out.printf("İlk tur ~%d µs, son tur ~%d µs%n", sureler[0], sureler[sureler.length - 1]);
30
31        System.out.println("""
32
33                --- JIT (Just-In-Time) derleyici ---
34                JVM kodu önce BYTECODE olarak YORUMLAR; sık çalışan ("hot") metotları çalışma anında
35                YERLEŞİK MAKİNE KODUNA derler (JIT) -> büyük hızlanma. Bu yüzden 'ısınma' (warmup) vardır:
36                ilk turlar genelde yavaş, sonraki turlar hızlıdır.
37                AMA yukarıdaki sayılara dikkat: tutarlı bir 'hep azalan' eğri GÖREMEYEBİLİRSİN!
38                Çünkü elle ölçüm GÜRÜLTÜLÜDÜR: GC duraklamaları, OS zamanlaması, JIT'in farklı anlarda
39                devreye girmesi, ölü-kod eleme ve inlining sonucu çarpıtır.
40                İŞTE ASIL DERS: güvenilir performans ölçümü elle System.nanoTime ile YAPILMAZ.
41                JMH (Java Microbenchmark Harness) kullan — warmup, çoklu iterasyon ve istatistik onunla doğru yapılır.""");
42    }
43}