What is Mark-and-Sweep GC?

Direct Answer

Mark-and-sweep is a tracing model with two phases: mark objects reachable from GC roots, then make unmarked space reusable. A basic non-compacting sweep can leave free regions between live objects. Production JVM collectors combine tracing with collector-specific copying, compaction, regions, barriers, and concurrent work.

Code Example

// Conceptual representation of mark-and-sweep
public class MarkSweepDemo {
    
    static class Node {
        String data;
        Node next;
        boolean marked = false; // GC mark bit
        
        Node(String data) { this.data = data; }
    }
    
    // Simulating the MARK phase
    static void markReachable(Node root) {
        if (root == null || root.marked) return;
        
        root.marked = true; // Mark this object as reachable
        markReachable(root.next); // Traverse to next
    }
    
    // Simulating the SWEEP phase
    static void sweepUnreachable(List<Node> heap) {
        heap.removeIf(node -> !node.marked);
        // In real GC, this reclaims memory
        // Unmarked objects are dead and removed
    }
}

Common Mistakes & Pitfalls

• Treating the teaching model as every JVM collector: A basic non-compacting mark-and-sweep scans and frees unmarked areas, but production collectors use different regions and phases.
• Assuming marking must all stop the world: Concurrent collectors can mark while application threads run, using barriers and short synchronization pauses to preserve correctness.
• Forgetting fragmentation: A non-compacting sweep can leave separated free regions. Copying, compaction, or region-based allocation can address that cost in collector-specific ways.