Functioneel programmeren met Clojure en backendontwikkeling op de JVM · Les

Geheugenbeheer en GC-druk verminderen

Begrijp garbage collection op de JVM en leer concrete Clojure-technieken om allocaties en GC-pauzes in kritieke codepaden te verminderen.

Les 4 van 413 stappen

Geheugenbeheer en GC-druk verminderen is een gratis Functioneel programmeren met Clojure en backendontwikkeling op de JVM-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Functioneel programmeren met Clojure en backendontwikkeling op de JVM. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Functioneel programmeren met Clojure en backendontwikkeling op de JVM bevat in totaal 4 lessen.

Waarom GC belangrijk is

De JVM maakt automatisch ongebruikt geheugen vrij via garbagecollection. GC-pauzes kunnen de latentie echter verslechteren. Minder toewijzingen betekenen minder werk voor GC en soepelere prestaties.

Generatieheap

De heap van de JVM is opgesplitst in generaties. De meeste objecten verdwijnen snel, dus de jonge generatie wordt vaak en efficiënt verzameld; overlevende objecten gaan naar de oude generatie.

Toewijzingen in Clojure

De onveranderlijke gegevensstructuren van Clojure delen hun structuur efficiënt, maar transformaties maken nog steeds nieuwe toewijzingen. In krappe lussen lopen deze toewijzingen op.

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

Transients

Met transients kun je verzamelingen tijdelijk veranderbaar maar veilig opbouwen, waardoor tussentijdse toewijzingen worden vermeden. Zet ze terug om met persistent!.

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

Boxing vermijden

Primitieve getallen worden in objecten verpakt wanneer ze in generieke verzamelingen worden opgeslagen. Typeaanwijzingen en rekenwerk met primitieven vermijden deze overhead.

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

Buffers hergebruiken

Voor I/O en rekenwerk met getallen vermindert het hergebruiken van arrays in plaats van per aanroep nieuwe arrays toe te wijzen de druk op GC aanzienlijk.

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

Luie reeksen en geheugen

Luie reeksen wijzen knooppunten voor reeksen toe en kunnen de kop in het geheugen vasthouden. Geef voor zuivere transformaties de voorkeur aan reduce of transducers, die tussentijdse verzamelingen vermijden.

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

Een verzamelaar kiezen

Moderne JVM's bieden verzamelaars die zijn afgestemd op verschillende doelen:

G1: evenwichtige standaardkeuze
ZGC / Shenandoah: zeer korte pauzes
Parallel: maximale doorvoer, langere pauzes

; enable ZGC
; java -XX:+UseZGC -jar app.jar

GC meten

Schakel GC-logboekregistratie in om de frequentie en duur van pauzes te zien voordat je gaat afstemmen. Raad nooit; meet.

; java -Xlog:gc -jar app.jar

De heapgrootte goed kiezen

Stel de minimale en maximale heapgrootte gelijk om pauzes door aanpassen van de grootte te voorkomen, en baseer de grootte op de werkelijke werkset. Een te kleine heap veroorzaakt frequente GC; een te grote heap verspilt geheugen en maakt verzamelingen van de oude generatie langer.

; java -Xms2g -Xmx2g -jar app.jar

Een afstemmingsworkflow

Praktische cyclus: profileer om veelvuldige toewijzingen te vinden, pas transients, primitieven en transducers toe, meet de GC-logboeken en stem daarna pas de verzamelaar en heap af als dat nodig is.

Korte controle

Test je kennis van geheugenafstemming.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd hoe je de druk op GC in Clojure vermindert.

Gebruik transients, primitieven en transducers om het aantal toewijzingen te verminderen
Hergebruik buffers in veelgebruikte codepaden
Meet met GC-logboeken en stem daarna de verzamelaar en heapgrootte af

Gratis beginnen

Leer Clojure met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Geheugenbeheer en GC-druk verminderen” gratis?

Ja — de volledige tekst van “Geheugenbeheer en GC-druk verminderen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Functioneel programmeren met Clojure en backendontwikkeling op de JVM wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Functioneel programmeren met Clojure en backendontwikkeling op de JVM bevat in totaal 4 lessen.

Wat leer ik in “Geheugenbeheer en GC-druk verminderen”?

Begrijp garbage collection op de JVM en leer concrete Clojure-technieken om allocaties en GC-pauzes in kritieke codepaden te verminderen. Je oefent met Functioneel programmeren met Clojure en backendontwikkeling op de JVM door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Functioneel programmeren met Clojure en backendontwikkeling op de JVM te beginnen?

Ervaring vooraf is niet nodig. Functioneel programmeren met Clojure en backendontwikkeling op de JVM op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Geheugenbeheer en GC-druk verminderen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Functioneel programmeren met Clojure en backendontwikkeling op de JVM?

Ja. Elke les over Functioneel programmeren met Clojure en backendontwikkeling op de JVM bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Functioneel programmeren met Clojure en backendontwikkeling op de JVM