0Pricing
Clojure Functional Programming & JVM Backend Development · Pelajaran

Pengelolaan Memori & Mengurangi Tekanan GC

Pahami pengumpulan sampah JVM dan pelajari teknik konkret Clojure untuk mengurangi alokasi serta jeda GC di jalur kode yang sering dijalankan.

Pengelolaan Memori & Mengurangi Tekanan GC adalah pelajaran Clojure Functional Programming & JVM Backend Development gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. 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 Clojure Functional Programming & JVM Backend Development, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Clojure Functional Programming & JVM Backend Development mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Why GC Matters

The JVM automatically reclaims unused memory through garbage collection. But GC pauses can hurt latency. Reducing allocations means less GC work and smoother performance.

Generational Heap

The JVM heap is split into generations. Most objects die young, so the young generation is collected often and cheaply; survivors move to the old generation.

Allocation in Clojure

Clojure's immutable data structures share structure efficiently, but transformations still allocate. In tight loops these allocations add up.

; each map call allocates a new seq node
(reduce + (map inc (range 1000000)))

Transients

Transients allow temporary, mutable-but-safe building of collections, avoiding intermediate allocations. Convert back with persistent!.

(defn build [n]
  (persistent!
    (reduce conj! (transient []) (range n))))

Avoiding Boxing

Primitive numbers get boxed into objects when stored in generic collections. Type hints and primitive math avoid this overhead.

(defn sum-sq ^long [^long n]
  (loop [i 0 acc 0]
    (if (< i n)
      (recur (inc i) (+ acc (* i i)))
      acc)))

Reusing Buffers

For I/O and number crunching, reusing arrays instead of allocating per call reduces GC pressure significantly.

(let [buf (byte-array 8192)]
  (loop []
    (let [n (.read in buf)]
      (when (pos? n)
        (.write out buf 0 n)
        (recur)))))

Lazy Seqs and Memory

Lazy sequences allocate seq nodes and can hold the head in memory. For pure transformations, prefer reduce or transducers, which avoid intermediate collections.

(transduce (comp (map inc) (filter even?)) + 0 (range 1000000))

Choosing a Collector

Modern JVMs offer collectors tuned for different goals:

  • G1: balanced default
  • ZGC / Shenandoah: very low pause times
  • Parallel: max throughput, longer pauses
; enable ZGC
; java -XX:+UseZGC -jar app.jar

Measuring GC

Enable GC logging to see pause frequency and duration before tuning. Never guess; measure.

; java -Xlog:gc -jar app.jar

Right-Sizing the Heap

Set min and max heap equal to avoid resize pauses, and size based on real working set. Too small causes frequent GC; too large wastes memory and lengthens old-gen collections.

; java -Xms2g -Xmx2g -jar app.jar

A Tuning Workflow

Practical loop: profile to find hot allocations, apply transients/primitives/transducers, measure GC logs, then tune the collector and heap only if needed.

Quick Check

Test your memory tuning knowledge.

Recap

You learned to reduce GC pressure in Clojure.

  • Use transients, primitives, and transducers to cut allocations
  • Reuse buffers in hot paths
  • Measure with GC logs, then tune collector and heap size

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengelolaan Memori & Mengurangi Tekanan GC” gratis?

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

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

Pahami pengumpulan sampah JVM dan pelajari teknik konkret Clojure untuk mengurangi alokasi serta jeda GC di jalur kode yang sering dijalankan. Kamu berlatih Clojure Functional Programming & JVM Backend Development 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 Clojure Functional Programming & JVM Backend Development?

Tidak diperlukan pengalaman sebelumnya. Clojure Functional Programming & JVM Backend Development 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 4 dari 4.

Berapa lama pelajaran “Pengelolaan Memori & Mengurangi Tekanan 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 Clojure Functional Programming & JVM Backend Development ini?

Ya. Setiap pelajaran Clojure Functional Programming & JVM Backend Development 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

  1. Membuat Profil Aplikasi Clojure
  2. Praktik Terbaik Kinerja JVM
  3. Pembandingan dan Optimasi Titik Panas
  4. Pengelolaan Memori & Mengurangi Tekanan GC
← Kembali ke Clojure Functional Programming & JVM Backend Development