Object References and Garbage Collection

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

// PRIMITIVE VALUES - Copied by value, compared by value
let a: number = 42;
let b: number = a;      // b gets a COPY of 42
b = 100;                // Changing b doesn't affect a
console.log(a);         // 42 - unchanged
 
let str1: string = "hello";
let str2: string = "hello";
console.log(str1 === str2);  // true - strings compared by value in JS
 
// OBJECT REFERENCES - Copied by reference, compared by identity
let obj1 = { name: "Alice" };
let obj2 = obj1;        // obj2 gets a COPY OF THE REFERENCE
                        // Both point to the SAME object on the heap
 
obj2.name = "Bob";      // Modifying through obj2...
console.log(obj1.name); // "Bob" - obj1 sees the change!
 
// Reference comparison checks identity, not contents
let obj3 = { name: "Bob" };
console.log(obj1 === obj2);  // true - same object
console.log(obj1 === obj3);  // false - different objects, same contents
 
// Creating the reference graph
class Node {
    value: number;
    children: Node[] = [];
    
    constructor(value: number) {
        this.value = value;
    }
}
 
const root = new Node(1);        // Object A on heap
const child1 = new Node(2);      // Object B on heap
const child2 = new Node(3);      // Object C on heap
 
root.children.push(child1);      // A references B
root.children.push(child2);      // A references C
child1.children.push(child2);    // B also references C
 
// Reference graph:
//     root (A)
//    /        \
//  child1 (B)  child2 (C)
//    \         /
//     \-------/
// 
// C has two incoming references (from A and B)
// If we clear root.children, both B and C become unreachable

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

GC ROOTS                         HEAP OBJECTS
═══════════                       ════════════
 
┌─────────────┐
│ Stack Frame │                   ┌─────────┐
│  localVar ──┼──────────────────►│ Object A│
└─────────────┘                   │ field1 ─┼──────┐
                                  │ field2 ─┼──┐   │
                                  └─────────┘  │   │
                                               │   │
┌─────────────┐                   ┌─────────┐  │   │    ┌─────────┐
│ Static Field│                   │ Object B│◄─┘   └───►│ Object C│
│  classVar ──┼──────────────────►│ child ──┼─────────►│         │
└─────────────┘                   └─────────┘          └─────────┘
                                               
┌─────────────┐                   ┌─────────┐
│ Thread Local│                   │ Object D│  ← NO PATH FROM ROOTS!
│   (none)    │                   │         │    This is GARBAGE
└─────────────┘                   └─────────┘
                                  
                                  ┌─────────┐     ┌─────────┐
                                  │ Object E│────►│ Object F│
                                  │         │◄────│         │
                                  └─────────┘     └─────────┘
                                  ↑ Circular reference but NO root path
                                    Both E and F are GARBAGE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// Conceptual reference counting (languages implement this internally)
 
class RefCountedObject {
    private refCount: number = 0;
    private data: any;
    
    // Called when a new reference is created
    addRef(): void {
        this.refCount++;
    }
    
    // Called when a reference is removed
    release(): void {
        this.refCount--;
        if (this.refCount === 0) {
            this.cleanup();  // Immediate deallocation
        }
    }
    
    private cleanup(): void {
        // Release any objects this object references
        if (this.data && this.data.release) {
            this.data.release();
        }
        // Free this object's memory
        console.log("Object deallocated");
    }
}
 
// THE CYCLE PROBLEM:
class CyclicNode {
    refCount = 1;
    partner: CyclicNode | null = null;
}
 
const a = new CyclicNode();  // refCount = 1
const b = new CyclicNode();  // refCount = 1
 
a.partner = b;  // b.refCount = 2
b.partner = a;  // a.refCount = 2
 
// Now clear the original references
// a = null;  // a.refCount = 1 (still referenced by b)
// b = null;  // b.refCount = 1 (still referenced by a)
 
// Neither can reach 0! Memory leak without cycle detection.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

MARK PHASE:
═══════════
Starting from roots, traverse and mark reachable objects
 
Root ──► [A ✓] ──► [B ✓] ──► [C ✓]
              │
              └──► [D ✓]
 
         [E  ]          [F  ]     (not reachable, not marked)
              ↑____↓
               cycle
 
 
SWEEP PHASE:
════════════
Scan heap, free unmarked objects
 
BEFORE:  [A ✓][E  ][B ✓][F  ][C ✓][D ✓]
                ↓       ↓
AFTER:   [A ✓][FREE][B ✓][FREE][C ✓][D ✓]
 
Clear marks for next cycle:
         [A  ][FREE][B  ][FREE][C  ][D  ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

BEFORE GC:
══════════
        ┌─────────── FROM-SPACE ───────────┐  ┌─────────── TO-SPACE ────────────┐
        │ [A][B][dead][C][dead][dead][D]   │  │         (empty)                 │
        └──────────────────────────────────┘  └─────────────────────────────────┘
                allocation ──────►                  
 
DURING GC (Copy live objects):
══════════════════════════════
        ┌─────────── FROM-SPACE ───────────┐  ┌─────────── TO-SPACE ────────────┐
        │ [A][B][dead][C][dead][dead][D]   │  │ [A'][B'][C'][D']                │
        └──────────────────────────────────┘  └─────────────────────────────────┘
                     │                                    │
                     └────── Copy live objects ───────────┘
 
AFTER GC (Swap spaces):
═══════════════════════
        ┌─────────── TO-SPACE ─────────────┐  ┌─────────── FROM-SPACE ──────────┐
        │         (empty, available)       │  │ [A][B][C][D]                    │
        └──────────────────────────────────┘  └─────────────────────────────────┘
                                                    allocation ──────►

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

YOUNG GENERATION                                    OLD GENERATION
════════════════                                    ══════════════
 
┌────────────────────────────────────────┐         ┌──────────────────────┐
│  EDEN SPACE          │ S0    │ S1     │         │                      │
│                      │       │        │         │  Long-lived objects  │
│  New allocations     │Survivor│Survivor│ ─────► │  promoted after N    │
│  happen here         │Space 0│Space 1 │         │  GC cycles           │
│                      │       │        │         │                      │
└────────────────────────────────────────┘         └──────────────────────┘
 
MINOR GC (Young Generation Only):
════════════════════════════════
1. Eden fills up → triggers Minor GC
2. Scan roots and Eden for live objects
3. Copy live objects to empty survivor space (S0 or S1)
4. Objects surviving N minor GCs → promote to Old Gen
5. Swap survivor spaces
6. Clear Eden
 
MAJOR GC (Full Heap):
═════════════════════
1. Old Generation fills up → triggers Major/Full GC
2. Collect both Young and Old generations
3. May compact Old Generation
4. Significantly more expensive than Minor GC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

INITIAL STATE:                    AFTER MARKING ROOT:
══════════════                    ═══════════════════
 
    [Root]                            [Root]
       │                                 │ 
       ▼                                 ▼
    [A] ─────► [B]                    [A] ─────► [B]
     │                                 │ gray     │ white
     ▼                                 ▼
    [C] ─────► [D]                    [C]        [D]
                                       white      white
 
All objects start WHITE            Root marked BLACK, A marked GRAY
 
 
AFTER PROCESSING A:               AFTER PROCESSING B & C:
═══════════════════               ═════════════════════
 
    [Root]                            [Root]
       │                                 │ 
       ▼                                 ▼
    [A] ─────► [B]                    [A] ─────► [B]
     │ black   │ gray                 │ black   │ black
     ▼                                 ▼
    [C]        [D]                    [C]  ───► [D]
     gray       white                 black     gray
 
 
FINAL STATE:
════════════
 
    [Root]                        All reachable objects marked BLACK
       │                          Any remaining WHITE objects are garbage
       ▼
    [A] ─────► [B]                If [E] exists and is WHITE, it's collected
     │ black   │ black
     ▼
    [C]  ───► [D]
     black     black

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

// ❌ HIGH GC PRESSURE: Creating objects in hot loops
 
function processEventsHeavy(events: EventData[]): Summary {
    let totalValue = 0;
    
    for (const event of events) {
        // New object created EVERY iteration
        const processed = {
            id: event.id,
            value: event.value * 1.1,
            timestamp: new Date(),
        };
        totalValue += processed.value;
        
        // Each 'processed' becomes garbage immediately after use
    }
    
    return { total: totalValue };
}
// For 10M events: creates 10M objects that immediately become garbage
 
// ✅ LOW GC PRESSURE: Reuse objects, avoid allocations in loops
 
interface ProcessedEvent {
    id: string;
    value: number;
    timestamp: Date;
}
 
function processEventsLight(events: EventData[]): Summary {
    let totalValue = 0;
    
    // Reuse a single object
    const processed: ProcessedEvent = { id: '', value: 0, timestamp: new Date() };
    
    for (const event of events) {
        processed.id = event.id;
        processed.value = event.value * 1.1;
        // Don't create new Date - reuse or skip if not needed
        
        totalValue += processed.value;
    }
    
    return { total: totalValue };
}
// For 10M events: creates only 2-3 objects total
 
 
// ✅ EVEN BETTER: Use primitives when possible
 
function processEventsPrimitive(events: EventData[]): number {
    let totalValue = 0;
    
    for (const event of events) {
        // Primitives don't create heap allocations
        totalValue += event.value * 1.1;
    }
    
    return totalValue;
}
// Zero new heap allocations in the hot loop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Throughput-oriented (for batch processing)
java -XX:+UseParallelGC \
     -Xms8g -Xmx8g \
     -XX:NewRatio=2 \
     -XX:ParallelGCThreads=8 \
     -jar batch-processor.jar
 
# Low-latency (for web services)
java -XX:+UseG1GC \
     -Xms4g -Xmx4g \
     -XX:MaxGCPauseMillis=50 \
     -XX:G1HeapRegionSize=16m \
     -jar web-service.jar
 
# Ultra-low-latency (for trading systems)
java -XX:+UseZGC \
     -Xms16g -Xmx16g \
     -XX:SoftMaxHeapSize=14g \
     -jar trading-engine.jar
 
# Enable GC logging for analysis
java -Xlog:gc*:file=gc.log:time,uptime:filecount=5,filesize=10m \
     -jar application.jar

1
2
3
4
5
6
7
8
9
10
11

# Increase old space size (for large data applications)
node --max-old-space-size=4096 app.js
 
# Expose GC for manual triggering (debugging only)
node --expose-gc app.js
 
# Enable detailed GC tracing
node --trace-gc app.js
 
# Tune for server workloads
node --optimize-for-size --max-old-space-size=2048 server.js