Scala for Backend Engineering & Functional Programming · Pelajaran

Pengelolaan Memori & Penyetelan GC

Dalami pengelolaan memori JVM, pengumpulan sampah, dan teknik untuk mengoptimalkan penggunaan memori di Scala.

Pengelolaan Memori & Penyetelan GC adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Pengantar Memori JVM & GC

Selamat datang! Dalam pelajaran ini, kita akan membahas cara Java Virtual Machine (JVM) mengelola memori, yang sangat penting khususnya bagi aplikasi Scala.

Memahami memori membantu Anda menulis kode yang efisien dan berkinerja tinggi.
Kita akan menjelajahi Garbage Collection (GC), pengelola memori otomatis milik JVM.
Pengelolaan memori yang tepat mencegah masalah umum seperti kesalahan "memori habis".

Heap: Penyimpanan Objek

Heap adalah area memori terbesar dalam JVM, tempat semua objek yang dibuat oleh aplikasi Scala Anda berada. Ini mencakup instans kelas, larik, dan sebagian besar struktur data.

Heap digunakan bersama oleh semua utas dalam aplikasi Anda. Ukurannya secara langsung memengaruhi jumlah objek yang dapat ditampung program Anda secara bersamaan.

Stack vs. Heap: Perbedaan Utama

Sementara Heap menyimpan objek, Stack menyimpan variabel lokal (terutama tipe primitif dan referensi objek) serta bingkai pemanggilan metode. Setiap utas memiliki Stack-nya sendiri.

Heap: Menyimpan objek, digunakan bersama, dikelola oleh GC.
Stack: Menyimpan pemanggilan metode dan variabel lokal, khusus untuk setiap utas, dikelola secara otomatis saat metode dimasuki atau ditinggalkan.

Memahami perbedaan ini adalah kunci untuk menelusuri masalah memori.

Dasar-Dasar Garbage Collection

Garbage Collection (GC) adalah proses otomatis JVM untuk menemukan dan mengambil kembali memori yang ditempati objek yang tidak lagi dapat "dijangkau" oleh aplikasi.

Alih-alih membebaskan memori secara manual seperti dalam C++, Scala (dan Java) mengandalkan GC untuk mencegah kebocoran memori dan menyederhanakan pengembangan. Gagasan utamanya adalah "menandai dan menyapu": tandai objek yang dapat dijangkau, lalu sapu objek lainnya.

Penjelasan GC Generasional

Sebagian besar GC modern menggunakan pendekatan generasional, dengan membagi Heap menjadi beberapa area berdasarkan usia objek:

Generasi Muda: Tempat objek baru dialokasikan. Sebagian besar objek mati di sini saat masih muda.
Generasi Tua: Objek yang bertahan melalui beberapa GC di Generasi Muda dipindahkan ke sini.

Hal ini memungkinkan GC yang lebih sering dan lebih cepat pada Generasi Muda (GC Minor), serta GC yang lebih jarang dan lebih lambat pada Generasi Tua (GC Mayor).

Koleksi Scala & Memori

Penekanan Scala pada imutabilitas dan pemrograman fungsional sering kali berarti pembuatan banyak objek berumur pendek, terutama selama transformasi koleksi.

GC dioptimalkan untuk hal ini. Mari kita lihat contoh pembuatan objek sementara saat memproses daftar:

object Main {
  def main(args: Array[String]): Unit = {
    println("Creating and transforming a list...")
    val originalList = (1 to 100000).toList // ~100k objects
    val transformedList = originalList.map(x => x * 2).filter(_ % 3 == 0)
    println(s"Transformed list size: ${transformedList.size}")
    // originalList and intermediate lists from map are now eligible for GC
    println("Intermediate objects are efficiently managed by GC.")
  }
}

Skenario Kebocoran Memori yang Umum

Bahkan dengan GC, kebocoran memori dapat terjadi ketika objek secara tidak sengaja tetap hidup karena referensi kuat. Skenario umum dalam Scala meliputi:

Cache Berumur Panjang: Menyimpan objek tanpa batas dalam peta global yang dapat diubah.
Closure: Closure (literal fungsi) menangkap objek besar yang tetap hidup lebih lama daripada cakupan yang seharusnya dimiliki closure tersebut.
Sumber Daya yang Tidak Ditutup: Tidak menutup handle file atau koneksi jaringan dengan benar.

Referensi Lemah untuk Caching

Untuk cache yang memungkinkan GC mengambil kembali memori jika suatu objek hanya direferensikan oleh cache, gunakan java.lang.ref.WeakReference.

WeakReference tidak mencegah objek yang dirujuknya dikumpulkan oleh garbage collector. Jika satu-satunya referensi yang tersisa ke suatu objek adalah referensi lemah, objek tersebut memenuhi syarat untuk dikumpulkan oleh GC.

import java.lang.ref.WeakReference

object Main {
  def main(args: Array[String]): Unit = {
    var largeData: Array[Byte] = new Array[Byte](1024 * 1024) // 1MB
    val weakCacheEntry = new WeakReference(largeData)

    println(s"Data exists via weak ref: ${weakCacheEntry.get() != null}")

    largeData = null // Remove the strong reference

    System.gc() // Hint to the JVM to run GC
    Thread.sleep(100) // Give GC time to run

    println(s"Data collected (possibly): ${weakCacheEntry.get() == null}")
    println("WeakReference allows GC to clean up if no strong references remain.")
  }
}

Bendera Dasar JVM untuk Penyetelan GC

Meskipun GC berjalan secara otomatis, Anda dapat menyetel perilakunya menggunakan argumen JVM. Bendera utamanya meliputi:

-Xmx: Menetapkan ukuran maksimum heap Java (misalnya, -Xmx4g untuk 4 gigabita).
-Xms: Menetapkan ukuran heap Java awal (misalnya, -Xms512m untuk 512 megabita).
-XX:+UseG1GC: Menentukan pengumpul Garbage-First (G1), pilihan umum pada JVM modern.

Menyetel bendera ini dapat berdampak besar pada kinerja aplikasi dan penggunaan memori.

Uji Pemahaman Anda

Pernyataan manakah berikut ini tentang pengelolaan memori JVM dan Garbage Collection yang BENAR?

Ringkasan: Memori & GC

Kerja bagus! Anda telah menjelajahi dasar-dasar pengelolaan memori JVM dan Garbage Collection:

Heap menyimpan objek, sedangkan Stack menyimpan pemanggilan metode dan variabel lokal.
GC secara otomatis mengambil kembali memori dari objek yang tidak dapat dijangkau.
Memahami GC generasional (generasi Muda/Tua) membantu mengoptimalkan kinerja.
Waspadai kebocoran memori dan gunakan alat seperti WeakReference untuk kebutuhan caching tertentu.
Bendera JVM dasar seperti -Xmx dan -Xms mengendalikan ukuran heap.

Selanjutnya, kita akan membahas alat pembuatan profil untuk mengidentifikasi hambatan!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengelolaan Memori & Penyetelan GC” gratis?

Ya — teks lengkap “Pengelolaan Memori & Penyetelan GC” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Pengelolaan Memori & Penyetelan GC”?

Dalami pengelolaan memori JVM, pengumpulan sampah, dan teknik untuk mengoptimalkan penggunaan memori di Scala. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 3.

Berapa lama pelajaran “Pengelolaan Memori & Penyetelan GC” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming