Java’da Garbage Collection Algoritmaları: Bellek Yönetiminin Temel Taşları

Java, otomatik bellek yönetimi ile öne çıkan bir programlama dilidir. Bu otomatik bellek yönetimi, Garbage Collection (Çöp Toplama) algoritmaları aracılığıyla gerçekleştirilmektedir. Bu makalede, Java’da kullanılan bazı temel Garbage Collection algoritmalarını inceleyeceğiz.

Bellek yönetiminin en önemli unsurlarından biri olan garbage collector’a neden ihtiyaç duyuyoruz peki; Çünkü kullanılmayan nesnelerin heap bellek üzerinde yer kaplamaması gerekiyor.

Ayrıca burada anlatılan algoritmaların ayrıntılı anlatımlarını da bir yazı dizisi şeklinde paylaşmayı planlıyorum.

1. Seri Toplama (Serial Garbage Collector) ile bellek yönetimi

Serial Garbage Collector, Java‘nın başlangıç dönemlerinde kullanılan en basit çöp toplama algoritmalarından biridir. Genellikle küçük ve orta ölçekli uygulamalarda tercih edilmektedir. Bu algoritma, uygulamanın diğer işlemlerini duraklatarak tek bir iş parçacığında (thread) çöp toplama işlemini gerçekleştirir. Bu nedenle, genellikle küçük uygulamalarda daha etkilidir.

Serial Garbage Collector’ı aktif etmek için aşağıdaki argument ile kullanabilirsiniz.

-XX:+UseSerialGC

2. Paralel Toplama (Parallel Garbage Collector)

Paralel Garbage Collector, çöp toplama işlemini diğer iş parçacıklarıyla paylaşarak paralel olarak gerçekleştiren bir algoritmadır. Serial Garbage Collector’a benzer şekilde, genellikle genel amaçlı uygulamalarda kullanılıyor. Özellikle çok çekirdekli sistemlerde performans avantajları sağlar.

Parallel Garbage Collector’ı aşağıdaki argument ile kullanabilirsiniz.

-XX:+UseParallelGC

3. CMS (Concurrent Mark-Sweep) Collector

CMS Collector, Concurrent Mark-Sweep olarak adlandırılan bir algoritma kullanır ve özellikle düşük duraklama süreleri gerektiren uygulamalarda tercih edilmelidir. Çalışma zamanında çöp toplama işlemini gerçekleştiren bu algoritma, uygulamanın performansını olumsuz etkilemeden bellek temizliği sağlar. Ancak, büyük bellek alanları ve yüksek kullanıcı sayılı uygulamalarda bazı duraklama süreleri yaşanma riski var.

CMS Garbage Collector’ı aktif etmek için aşağıdaki argument ile kullanabilirsiniz.

-XX:+UseConcMarkSweepGC

4. G1 (Garbage First) Collector

G1 Collector, genellikle büyük bellek havuzlarına sahip uygulamalarda kullanılan bir çöp toplama algoritmasıdır. Bu algoritma, uygulamanın ihtiyaçlarına göre optimize edilmiş bir şekilde çalışır. G1 Collector, genç nesil ve yaşlı nesil olmak üzere iki ana bölgeye odaklanarak, işlem süreçlerini dengeler ve büyük bellek bloklarının etkili bir şekilde yönetimini sağlar.

Garbage First Collector’ı aktif etmek için aşağıdaki argument ile kullanabilirsiniz.

-XX:+UseG1GC

5. ZGC (Z Garbage Collector) ve Shenandoah ile bellek yönetimi

Java platformu, zaman içinde gelişen ihtiyaçlara cevap verebilmek amacıyla yeni çöp toplama algoritmalarıyla zenginleştirilmiş durumda. Z Garbage Collector (ZGC) ve Shenandoah gibi algoritmalar, özellikle büyük ölçekli ve yüksek performanslı uygulamalarda kullanılmak üzere tasarlanmıştır. Bu algoritmalar, genellikle düşük duraklama süreleri ve yüksek işlemci verimliliği sağlamak için optimize edilmiştir.

Z Garbage Collector’ı kullanmak için ise sürüm bazlı bir kullanım gerekmektedir. Eğer java 15 sürümünden daha eski bir sürüm kullanılıyor ise;

-XX:+UnlockExperimentalVMOptions -XX:+UseZGC

Java 15 sürümünden itibaren ise Deneysel (Experimental) modun açılmasına gerek kalmadan kullanılabilir.

-XX:+UseZGC

Shenandoah’ı aktif etmek için ise java 12 kullanmak gerekiyor ancak 8 ve 11’e yönelik destek de sunuluyor. Shenandoah’ı aktif etmek için ise aşağıdaki argument ile kullanabilirsiniz.

-XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC

JVM’e parametre olarak girilmesinin dışında kod içerisinde de çağrım yapabilirsiniz. Bu çağrımlar için örnek kodu ise aşağıda bulabilirsiniz.

public class Main {
    public static void main(String[] args) {
        Runtime gfg = Runtime.getRuntime();
        long memoriesOne, memoriesTwo;
        Integer integer[] = new Integer[10000];

        //Checking The Total Memory - Toplam Bellegin kontrol edilmesi [tr]

        System.out.println("Total Memory is: " + gfg.totalMemory());

        //Checking Free Memory - Bos bellegin kontrol edilmesi [tr]

        memoriesOne = gfg.freeMemory();
        System.out.println("Initial Free Memory: " + memoriesOne);

        //Calling The Garbage Collector On Demand - Garbage Collector cagrimi yapiliyor [tr]
        gfg.gc();

        memoriesOne = gfg.freeMemory();

        System.out.println("Free Memory After Garbage Collection: " + memoriesOne);

        //Allocating Integers - Tam Sayilar icin bellek uzerinde bellek tahsisi yapilacak [tr]

        for (int i = 0; i < 10000; i++)
            integer[i] = i;

        memoriesTwo = gfg.freeMemory();

        System.out.println("Free Memory After Allocation: " + memoriesTwo);

        System.out.println("Memory Used by Allocation: " + (memoriesOne - memoriesTwo));

        // Discard Integers - Tam Sayilar icin bellek uzerinde ayrilan alandaki degerlerin atilmasi

        for (int i = 0; i < 10000; i++)
            integer[i] = null;

        //Calling The Garbage Collector On Demand - Garbage Collector cagrimi yapiliyor [tr]
        gfg.gc();

        memoriesTwo = gfg.freeMemory();

        System.out.println("Free Memory After Collecting Discarded Integers: " + memoriesTwo);
    }
}

Sonuç

Java’da kullanılan Garbage Collection algoritmaları, uygulamanın ihtiyaçlarına ve performans beklentilerine göre seçilmelidir. Her bir algoritma, farklı avantajlar ve dezavantajlar sunar. Geliştiriciler, uygulama gereksinimlerini dikkate alarak ve performans izleme araçları kullanarak en uygun çöp toplama stratejisini seçmelidir. Java’nın esnek çöp toplama algoritmaları, programcılara geniş bir yelpazede uygulama senaryolarına uygun çözümler sunar.