Geheugenlek: oorzaken, detectie en hoe je het oplost

Elk programma dat we draaien, groot of klein, heeft geheugen nodig om te verwerken. Maar wanneer een programma geheugen gebruikt en nalaat het na gebruik vrij te geven, leidt dat tot een geheugenlek. 

Na verloop van tijd kunnen meer geheugenlekken zorgen voor een tekort aan opslag en het niet kunnen verwerken van nieuwe taken. Daarom is het cruciaal om geheugenlekken te detecteren en te beheren om onnodige fouten te voorkomen.

In dit artikel duiken we dieper in geheugenlekken. Laten we beginnen!

Wat is een geheugenlek?

Geheugenlekken ontstaan wanneer een programma of applicatie geheugen gebruikt en het na gebruik niet vrijgeeft. Met geheugen bedoel ik RAM—verwar dit niet met harde schijfgeheugen.  Deze lekken stapelen zich geleidelijk op, waardoor het RAM te vol raakt om nieuwe processen te verwerken. 

Geheugenlekken putten het RAM uit en beïnvloeden de prestaties door het aantal I/O-bewerkingen te verhogen. Naarmate geheugenlekken zich opstapelen, probeert het systeem RAM vrij te maken door data naar de schijf te verplaatsen, wat leidt tot een toename van schijf-I/O-bewerkingen.

Ook de beveiliging loopt risico wanneer geheugenlekken gevoelige gegevens blokkeren. Als informatie zoals wachtwoorden of encryptiesleutels langer dan nodig in RAM blijft, is die kwetsbaarder voor aanvallers.

Voorbeelden van geheugenlekken in populaire programmeertalen

Om beter te begrijpen hoe geheugenlekken optreden, is er niets beters dan ze in actie te zien met enkele voorbeelden. 

Geheugenlekken in Python

Python vertrouwt voor geheugenbeheer op referentietelling. Het verwijdert een object wanneer de referentietelling—het aantal andere objecten dat ernaar verwijst—op nul komt. Het heeft echter bepaalde beperkingen, zoals het niet afhandelen van circulaire verwijzingen.

Voor wie niet bekend is met de term: een circulaire verwijzing ontstaat wanneer twee of meer variabelen op circulaire wijze naar elkaar verwijzen. 

Bijvoorbeeld: object a verwijst naar b, b verwijst naar c en c verwijst terug naar a, wat een eindeloze lus is. Hier kan de referentietelling nooit 0 worden en blijven de objecten voor altijd in het geheugen, wat tot geheugenlekken in Python leidt.

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None 

# Create two nodes
node1 = Node(1)
node2 = Node(2)

# Establish a circular reference
node1.next = node2  # node1 refers to node2
node2.next = node1  # node2 refers back to node1Mogelijk gemaakt door

De bovenstaande code laat een circulaire verwijzing zien. Python heeft een garbagecollector om deze scenario’s af te handelen. Toch als dat in specifieke gevallen niet lukt, zoals bij gebruik van globale variabelen, moet je geheugenlekken handmatig beheren door objectverwijzingen die niet meer worden gebruikt op None te zetten. 

Ik raad je aan om te leren hoe je geheugen­efficiënte classes in Python schrijft om de runtime te versnellen met minder resources.

Geheugenlekken in Java

Java beheert geheugen automatisch en heeft geen expliciete hulp van programmeurs nodig. Maar in gevallen zoals onjuiste registratie van listeners of statische verwijzingen kan de garbagecollector nalaten om ruimte vrij te maken, wat leidt tot geheugenlekken. Zo kan dat gebeuren:

• Een eventbron genereert events en een listener-object registreert zich om op de hoogte te worden gesteld wanneer die events plaatsvinden. 
• Als de eventbron een sterke referentie naar de listener vasthoudt, kan de listener niet worden opgehaald door de garbagecollector zolang de eventbron leeft, zelfs als de listener niet meer wordt gebruikt. 

In zulke gevallen kunnen geheugenlekken optreden. Om ze te voorkomen, moet je listeners handmatig uitschrijven zodra ze niet meer nodig zijn.

Een andere veelvoorkomende oorzaak van geheugenlekken is statische variabelen. Statische variabelen blijven gedurende de hele levensduur in het geheugen. Als ze dus naar objecten verwijzen, worden die objecten niet opgehaald door de garbagecollector, zelfs als ze niet meer in gebruik zijn, wat geheugenlekken veroorzaakt. Bijvoorbeeld:

import java.util.ArrayList;
import java.util.List;

public class StaticMemoryLeak {

    // Static list
    private static List<Object> staticList = new ArrayList<>();

    public static void addObject(Object obj) {
        // Add the object to the static list
        staticList.add(obj);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            Object obj = new byte[1024 * 1024];
            // Add the object to the static list
            addObject(obj);
        }
    }
}Mogelijk gemaakt door

In het bovenstaande programma is de variabele staticList gedeclareerd als een statische array en worden er objecten aan toegevoegd. De lus draait 1000 keer en voegt telkens 1 MB aan objecten toe, wat resulteert in in totaal 1 GB geheugen. 

Omdat de lijst statisch is, verliest hij zolang het programma leeft nooit de referenties naar de objecten. De garbagecollector kan die objecten dus niet verwijderen en 1 GB geheugen blijft gedurende de hele levensduur vastgehouden. Dit ongebruikte objectgeheugen kan OutOfMemoryError-fouten veroorzaken. Om dit op te lossen, moet je expliciet staticList.clear() aanroepen en het geheugen vrijgeven.

Geheugenlekken in C/C++

In tegenstelling tot Java en Python bevat C++ geen automatische garbagecollectors. Geheugenlekken in C++ ontstaan dus wanneer programmeurs geheugen reserveren en vergeten het vrij te geven. Bijvoorbeeld: 

void sample_leak() { 
    int* ptr = new int(5);
    return; 
}Mogelijk gemaakt door

In de bovenstaande snippet bevat de pointer het geheugenadres waar het geheel getal 5 is opgeslagen. Wanneer de functie eindigt, valt de lokale variabele ptr buiten scope, maar het geheugen dat op de heap is gereserveerd blijft bestaan, wat een geheugenlek veroorzaakt. 

Voorkom dit door expliciet de regel delete ptr; toe te voegen om het geheugen vrij te geven.

Geheugenlekken in JavaScript

JavaScript heeft een garbagecollector die het geheugen automatisch beheert. Die werkt in deze stappen: de root vinden, het pad ernaartoe recursief volgen voor kinderen en elk kind markeren als actief of inactief. Tot slot worden alle inactieve verwijzingen verwijderd. 

Toch kan de garbagecollector in de volgende gevallen het geheugen niet vrijgeven:

1. Globale variabelen: Wanneer je vergeet een variabele te declareren met let, var of const, maakt JavaScript die automatisch als globale variabele aan. Zolang het programma draait, blijven globale variabelen in het geheugen en zijn ze altijd bereikbaar, waardoor de garbagecollector ze niet kan vrijgeven. 
2. setTimeOut(): setTimeOut() plant een callbackfunctie in om na een bepaalde tijd te worden uitgevoerd. Een geheugenlek kan optreden wanneer deze callbackfunctie de referentie langer vasthoudt. Hier is een voorbeeld:

function TimeoutExample() {
  var obj = 10; 
  setTimeout(function() {
    console.log(obj); 
  }, 1000);  // This runs after 1 second
}

TimeoutExample();Mogelijk gemaakt door

In de bovenstaande code houdt obj zelfs nadat de functie TimeoutExample() is afgerond nog een referentie vast totdat de callbackfunctie is uitgevoerd, omdat obj binnen de callback wordt gebruikt. Als dit gebeurt met grote objecten, leidt dat tot serieuze geheugenlekken. 

Oorzaken van geheugenlekken

Zoals genoemd kunnen geheugenlekken in verschillende programmeertalen om verschillende redenen optreden. Sommige talen missen automatische garbagecollectie, terwijl andere in afwijkende scenario’s kunnen falen om geheugen vrij te geven. 

Laten we enkele veelvoorkomende redenen in detail bekijken:

• Niet-vrijgegeven referenties: Telkens wanneer we objecten of variabelen aanmaken, reserveert het systeem geheugen of referenties voor ze. Als je die referenties na gebruik niet sluit, kan dat het geheugen blokkeren. Dit soort geheugen hoopt zich na verloop van tijd op en leidt tot geheugenproblemen. 
• Circulaire verwijzingen: Circulaire verwijzingen ontstaan wanneer meerdere objecten naar elkaar verwijzen en zo een lus vormen. Ook al worden de objecten niet meer gebruikt, ze blijven door andere objecten in de cyclus verwezen, waardoor de garbagecollector hun geheugen niet kan terugwinnen.
• Onjuist resourcebeheer: Soms doen we geen extra moeite om databaseverbindingen, netwerk­sockets of bestands­handles na gebruik netjes te sluiten. Deze onachtzaamheid kan tot ernstige geheugenlekken leiden. Bijvoorbeeld: het OS heeft een beperkt aantal bestandsdescriptors om open bestanden te beheren. Als bestanden nooit worden gesloten, raakt het OS door zijn descriptors heen en kan het systeem geen nieuwe bestanden meer openen.
• Verkeerd gebruik van statische variabelen: Geheugenlekken komen vaak voor door overmatig gebruik van statische variabelen. Omdat statische variabelen de hele levensduur van het programma blijven bestaan, blijven alle objecten waarnaar ze verwijzen in het geheugen—zelfs als ze niet worden gebruikt. Om geheugenlekken te voorkomen, moeten deze objecten expliciet worden vrijgegeven of moet het gebruik van statische variabelen worden vermeden.
• Externe bibliotheken en frameworks: Bibliotheken van derden en externe frameworks kunnen ook geheugenlekken introduceren door inefficiënt resourcebeheer. Geheugenlekken ontstaan als ze je systeemresources gebruiken en die niet vrijgeven. 

Hoe detecteer je geheugenlekken?

Nu we hebben bekeken waarom geheugenlekken kunnen optreden, bespreken we enkele betrouwbare detectiemethoden om ze op te sporen en te debuggen.

• Handmatige inspectie: Bekijk de code zorgvuldig om mogelijke oorzaken van geheugenlekken te identificeren, zoals circulaire verwijzingen, statische variabelen, ontbrekende deallocatie­instructies of variabelen die referenties vasthouden naar ongebruikte objecten.  Door deze patronen grondig te inspecteren, kun je het exacte probleem vinden en het proactief aanpakken. 
• Debuggingtools gebruiken: Er zijn diverse debuggingtools en bibliotheken, eigen aan verschillende programmeertalen, voor het detecteren van geheugenlekken. Zo laat Python’s tracemalloc ons geheugensnapshots op verschillende tijdstippen vergelijken en geheugenallocaties tussen die periodes monitoren.  Bovendien kun je met Python’s memory profiler elke coderegel debuggen en delen met onverwacht hoog geheugengebruik opsporen.
• Geheugengebruik monitoren: Tools voor geheugenmonitoring houden het verbruik proactief in de gaten en sporen problemen in realtime op. Deze tools waarschuwen je voor kritieke geheugenproblemen en geven relevante logs, plus suggesties om ze op te lossen. Voorbeelden zijn Valgrind, Paessler, AddressSanitizer en anderen. 
• Tests voor lekken schrijven: Overweeg unit-tests toe te voegen die geheugenlekken detecteren. Zo worden geheugenlekken, naast functionele en prestatieproblemen, tijdens de ontwikkeling ontdekt. 
• Integratietests schrijven: Gebruik ook integratietests om realistische scenario’s te simuleren en potentiële geheugenlekken te detecteren die in productie kunnen ontstaan.

Best practices om geheugenlekken te voorkomen

Geheugenlekken komen vaak voor in applicaties die sterk op geheugenresources leunen. Hier zijn een paar praktijken die je kunt volgen om ze te voorkomen. 

Efficiënt resourcebeheer

Probeer taalen te gebruiken zoals Java of Python die geheugen automatisch afhandelen met garbagecollectors. Zorg er anders in talen als C of C++ voor dat al het gereserveerde geheugen expliciet wordt vrijgegeven. 

Gebruik daarnaast constructies zoals finally-blocks of contextmanagers zoals with in Python of try-with-resources in Java voor efficiënte opschoning van resources. Deze praktijken helpen geheugenlekken te voorkomen en zorgen voor goed resourcebeheer. 

Gebruik zwakke referenties

In tegenstelling tot sterke referenties voorkomen zwakke referenties niet dat objecten door de garbagecollector worden opgeruimd. Zelfs als ze referenties naar objecten vasthouden, tellen ze niet mee voor de bereikbaarheid van het object. De garbagecollector kan het bijbehorende geheugen dus terugwinnen. Gebruik daarom zwakke referenties in plaats van sterke. 

Regelmatige code reviews

Het is belangrijk om regelmatig code reviews uit te voeren om geheugenlekken te identificeren. Let tijdens het reviewen op veelvoorkomende patronen zoals niet-gesloten resources, circulaire verwijzingen, globale of statische variabelen en inefficiënte caching. Zo vind je het probleem snel voordat het je systeem beïnvloedt. 

Conclusie

In dit artikel hebben we de kernaspecten van geheugenlekken verkend: van oorzaken en voorbeelden tot detectietechnieken. We hebben gezien hoe verschillende scenario’s tot geheugenlekken kunnen leiden en hoe je ermee omgaat. Daarnaast hebben we de best practices besproken die je zou moeten volgen om toekomstige geheugenlekken te voorkomen.  

Omdat we geheugenlekken in verschillende programmeertalen hebben bekeken, raad ik je aan om de volgende cursussen te volgen om je begrip verder te verdiepen:

• Objectgeoriënteerd programmeren in Python
• Objectgeoriënteerd programmeren in Java