Lære How the Garbage Collector Works | Garbage Collection in Java

The garbage collector identifies unused objects by tracking references. If no part of your code can reach an object—meaning there are no variables or fields pointing to it—the object is considered "unreachable." Once an object becomes unreachable, the garbage collector knows it is safe to remove.

You do not need to call the garbage collector directly. It runs automatically in the background, checking for unreachable objects and clearing them away. This process helps prevent memory leaks and keeps your Java applications running efficiently.

Real-World Example: Memory Leaks Without Garbage Collection

Suppose you are developing a simple server application that processes incoming requests and stores user session data in a HashMap. If you forget to remove sessions when users log out, the HashMap will keep growing, holding references to unused session objects. Without garbage collection, this unused data would stay in memory, eventually causing the application to run out of memory and crash.

In Java, the garbage collector helps by automatically reclaiming memory for objects that are no longer referenced. However, if you keep references to unused objects (such as by leaving them in a HashMap), the garbage collector cannot remove them, leading to a memory leak.

Main.java


              1234567891011121314151617181920212223242526272829
            
package com.example;

import java.util.HashMap;
import java.util.UUID;

public class SessionManager {
    private final HashMap<String, String> sessions = new HashMap<>();

    public void createSession(String userId) {
        String sessionId = UUID.randomUUID().toString();
        sessions.put(sessionId, userId);
        System.out.println("Session created for user: " + userId);
    }

    // Intentionally missing: method to remove sessions when users log out

    public int getSessionCount() {
        return sessions.size();
    }

    public static void main(String[] args) {
        SessionManager manager = new SessionManager();
        for (int i = 0; i < 100000; i++) {
            manager.createSession("user" + i);
        }
        System.out.println("Total sessions stored: " + manager.getSessionCount());
        // Even if users are done, their sessions stay in memory
    }
}

Key points:

Java's garbage collector only removes objects with no active references;
If you keep references (like in a HashMap), memory is not freed, and your application can run out of memory;
Always remove references to objects you no longer need to allow the garbage collector to reclaim memory.

Var alt klart?

Tak for dine kommentarer!

Sektion 2. Kapitel 2

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Stryg for at vise menuen