Memory Management Considerations

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

import java.lang.ref.*;
 
public class ReferenceTypesDemo {
    public static void main(String[] args) {
        Object object = new Object();  // Strong reference
        
        // SOFT REFERENCE: Cleared under memory pressure
        SoftReference<Object> softRef = new SoftReference<>(object);
        
        // WEAK REFERENCE: Cleared when only weak refs remain
        WeakReference<Object> weakRef = new WeakReference<>(object);
        
        // PHANTOM REFERENCE: For post-finalization notification
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        PhantomReference<Object> phantomRef = new PhantomReference<>(object, queue);
        
        // Clear the strong reference
        object = null;
        
        // After GC, soft/weak refs may be cleared
        System.gc();  // Request GC (not guaranteed)
        
        // Check if references are still valid
        Object fromSoft = softRef.get();    // May be null
        Object fromWeak = weakRef.get();    // Likely null
        Object fromPhantom = phantomRef.get(); // ALWAYS null!
        
        // Phantom refs are checked via queue
        Reference<?> ref = queue.poll();
        if (ref == phantomRef) {
            System.out.println("Object was finalized");
        }
    }
}

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

// JavaScript WeakRef (ES2021)
 
class ExpensiveResource {
    data: ArrayBuffer;
    
    constructor(size: number) {
        this.data = new ArrayBuffer(size);
        console.log(`Created resource of ${size} bytes`);
    }
}
 
// Create the resource with a strong reference
let resource: ExpensiveResource | null = new ExpensiveResource(1024 * 1024);
 
// Create a weak reference to it
const weakRef = new WeakRef(resource);
 
// Get the resource through the weak reference
function useWeakResource(): void {
    // CRITICAL: Always check the result of deref()
    const maybeResource = weakRef.deref();
    
    if (maybeResource) {
        // Object is still alive - safe to use
        console.log(`Resource size: ${maybeResource.data.byteLength}`);
    } else {
        // Object was garbage collected - handle gracefully
        console.log('Resource was collected - recreating');
        // Option: recreate, fetch from source, or return error
    }
}
 
// While 'resource' variable exists, weak reference works
useWeakResource();  // Works
 
// Clear the strong reference
resource = null;
 
// After GC runs, the weak reference may be cleared
// (Note: GC timing is non-deterministic)
 
// IMPORTANT: Don't do this in a single tick!
// JavaScript's microtask/macrotask model means GC typically
// won't run between synchronous operations
 
// After some GC triggers...
setTimeout(() => {
    useWeakResource();  // May log "Resource was collected"
}, 10000);

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

TIME ──────────────────────────────────────────────────────────►
 
    ┌─────────┐     ┌─────────┐     ┌─────────┐     ┌─────────┐
    │ CREATED │ ─►  │ ACTIVE  │ ─►  │ CLEARED │ ─►  │  STALE  │
    └─────────┘     └─────────┘     └─────────┘     └─────────┘
         │               │               │               │
         │               │               │               │
         ▼               ▼               ▼               ▼
    
    WeakRef(obj)    get() → obj     GC runs         get() → null
    Strong ref       Strong ref      No strong refs   Object is gone
    exists           still exists    remain           
 
    
    OBJECT LIFECYCLE:
    
    ╔═══════════════════════════════════════════════════════════╗
    ║           OBJECT ALIVE            ║    OBJECT COLLECTED   ║
    ║  (reachable via strong refs)      ║  (memory reclaimed)   ║
    ╠═══════════════════════════════════╬═══════════════════════╣
    ║  WeakRef.deref() → object         ║  WeakRef.deref() → null
    ║  WeakMap.get(key) → value         ║  (entry auto-removed)  ║
    ╚═══════════════════════════════════╩═══════════════════════╝

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

// USE CASE 1: Associating private data with objects
// Without polluting the object or preventing its collection
 
const privateData = new WeakMap<object, PrivateState>();
 
class MyClass {
    constructor() {
        // Store private state keyed by 'this'
        privateData.set(this, {
            secret: 'hidden value',
            counter: 0
        });
    }
    
    increment(): number {
        const state = privateData.get(this)!;
        return ++state.counter;
    }
    
    // When MyClass instance is collected, WeakMap entry vanishes too
}
 
// USE CASE 2: Computed property cache that doesn't leak
 
class Document {
    constructor(public content: string) {}
}
 
const wordCountCache = new WeakMap<Document, number>();
 
function getWordCount(doc: Document): number {
    let count = wordCountCache.get(doc);
    
    if (count === undefined) {
        count = doc.content.split(/\s+/).length;
        wordCountCache.set(doc, count);
    }
    
    return count;
}
 
// Documents can be freely created and collected
// Cache entries automatically cleaned up
 
// USE CASE 3: Tracking DOM elements without preventing cleanup
 
const elementMetadata = new WeakMap<HTMLElement, ElementState>();
 
function trackElement(el: HTMLElement, state: ElementState): void {
    elementMetadata.set(el, state);
}
 
function getElementState(el: HTMLElement): ElementState | undefined {
    return elementMetadata.get(el);
}
 
// When DOM elements are removed and collected, metadata goes too
// No manual cleanup needed!

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

// WeakSet: Track object membership without preventing collection
 
class RequestProcessor {
    // Track which requests we've already processed
    private processedRequests = new WeakSet<Request>();
    
    async process(request: Request): Promise<Response> {
        // Check for duplicate processing
        if (this.processedRequests.has(request)) {
            throw new Error('Request already processed');
        }
        
        // Mark as processed
        this.processedRequests.add(request);
        
        // Do processing...
        const response = await this.doProcess(request);
        
        // When the Request object is no longer referenced elsewhere,
        // it will be collected and automatically removed from the set
        
        return response;
    }
    
    private async doProcess(request: Request): Promise<Response> {
        // ... actual processing
        return new Response('OK');
    }
}
 
// Real-world example: Tracking visited nodes in graph traversal
function traverseGraph(root: GraphNode): void {
    const visited = new WeakSet<GraphNode>();
    
    function visit(node: GraphNode): void {
        if (visited.has(node)) return;  // Already visited
        visited.add(node);
        
        // Process node...
        
        for (const child of node.children) {
            visit(child);
        }
    }
    
    visit(root);
    
    // After traversal, visited set can be garbage collected
    // No manual cleanup of the Set required
}

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
62
63
64
65
66
67
68
69
70
71
72
73

// JavaScript FinalizationRegistry
 
// Create a registry with a cleanup callback
const registry = new FinalizationRegistry<string>((heldValue) => {
    // Called when the registered object is collected
    // heldValue is the second argument passed to register()
    console.log(`Object collected. Held value: ${heldValue}`);
    
    // Typical cleanup: release external resources
    // WARNING: Cannot access the collected object itself!
});
 
interface ManagedResource {
    id: string;
    nativeHandle: number;  // Simulated native resource handle
}
 
function createResource(id: string): ManagedResource {
    const resource: ManagedResource = {
        id,
        nativeHandle: acquireNativeHandle()  // Simulated
    };
    
    // Register for cleanup notification
    // Arguments: (target, heldValue, unregisterToken?)
    registry.register(resource, `Handle:${resource.nativeHandle}`, resource);
    
    return resource;
}
 
// When 'resource' becomes unreachable and is collected,
// the callback will eventually fire with "Handle:123" (example)
 
// USE CASE: Cleaning up native resources
 
class DatabaseConnection {
    private static registry = new FinalizationRegistry<number>((handle) => {
        // This is a BACKUP cleanup - not primary!
        console.warn(`Connection ${handle} collected without explicit close!`);
        closeNativeConnection(handle);  // Release native resource
    });
    
    private handle: number;
    private closed = false;
    
    constructor() {
        this.handle = openNativeConnection();
        DatabaseConnection.registry.register(this, this.handle, this);
    }
    
    close(): void {
        if (this.closed) return;
        this.closed = true;
        
        // Unregister from finalization - cleanup is explicit
        DatabaseConnection.registry.unregister(this);
        
        closeNativeConnection(this.handle);
    }
}
 
// Good pattern: always close explicitly, registry is backup
async function useDatabase(): Promise<void> {
    const conn = new DatabaseConnection();
    
    try {
        await conn.query('SELECT ...');
    } finally {
        conn.close();  // Primary cleanup
    }
    
    // If close() wasn't called (bug), finalization will eventually run
}

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

// C# WeakReference<T>
public class CacheExample
{
    // WeakReference allows object to be collected
    private WeakReference<ExpensiveObject> _cached = 
        new WeakReference<ExpensiveObject>(null);
    
    public ExpensiveObject GetOrCreate()
    {
        // TryGetTarget returns false if object was collected
        if (_cached.TryGetTarget(out ExpensiveObject obj))
        {
            return obj;  // Cache hit
        }
        
        // Cache miss - recreate
        obj = new ExpensiveObject();
        _cached.SetTarget(obj);
        return obj;
    }
}
 
// C# ConditionalWeakTable - like WeakMap
using System.Runtime.CompilerServices;
 
public static class ObjectExtensions
{
    // Private data associated with objects
    private static readonly ConditionalWeakTable<object, PrivateData> _data = 
        new ConditionalWeakTable<object, PrivateData>();
    
    public static void SetPrivateData(this object obj, PrivateData data)
    {
        _data.AddOrUpdate(obj, data);
    }
    
    public static PrivateData GetPrivateData(this object obj)
    {
        _data.TryGetValue(obj, out PrivateData data);
        return data;
    }
}
 
// C# Finalization (use sparingly)
public class ResourceWrapper : IDisposable
{
    private IntPtr _nativeHandle;
    private bool _disposed = false;
    
    public ResourceWrapper()
    {
        _nativeHandle = NativeMethods.Acquire();
    }
    
    ~ResourceWrapper()  // Finalizer
    {
        // Called by GC - ONLY for unmanaged resources
        Dispose(false);
    }
    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);  // No need for finalizer now
    }
    
    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;
        _disposed = true;
        
        if (disposing)
        {
            // Release managed resources
        }
        
        // Always release unmanaged resources
        if (_nativeHandle != IntPtr.Zero)
        {
            NativeMethods.Release(_nativeHandle);
            _nativeHandle = IntPtr.Zero;
        }
    }
}

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

// Ensure unique instances for equal keys - without memory leaks
 
class CanonicalMap<K, V extends object> {
    // We need a regular Map because WeakMap keys must be objects
    // and we want to canonicalize by value (e.g., strings)
    private map = new Map<K, WeakRef<V>>();
    private finalization = new FinalizationRegistry<K>((key) => {
        // Clean up the map entry when value is collected
        const ref = this.map.get(key);
        if (ref && !ref.deref()) {
            this.map.delete(key);
        }
    });
    
    getOrCreate(key: K, factory: () => V): V {
        const ref = this.map.get(key);
        if (ref) {
            const value = ref.deref();
            if (value) return value;  // Cache hit
        }
        
        // Create new instance
        const value = factory();
        this.map.set(key, new WeakRef(value));
        this.finalization.register(value, key);
        
        return value;
    }
}
 
// Usage: Canonical Symbol instances
class Symbol {
    constructor(public readonly name: string) {}
}
 
const symbols = new CanonicalMap<string, Symbol>();
 
function getSymbol(name: string): Symbol {
    return symbols.getOrCreate(name, () => new Symbol(name));
}
 
const sym1 = getSymbol('foo');
const sym2 = getSymbol('foo');
console.log(sym1 === sym2);  // true - same instance
 
// When no strong references to a Symbol remain, it can be collected

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
62
63
64
65
66
67

// Observable that doesn't hold strong references to observers
 
interface Observer<T> {
    onUpdate(value: T): void;
}
 
class WeakObservable<T> {
    private observers: Set<WeakRef<Observer<T>>> = new Set();
    private value: T;
    
    constructor(initial: T) {
        this.value = initial;
    }
    
    subscribe(observer: Observer<T>): void {
        this.observers.add(new WeakRef(observer));
    }
    
    // No unsubscribe needed! Collected observers are automatically ignored.
    // But we can provide one for explicit removal:
    unsubscribe(observer: Observer<T>): void {
        for (const ref of this.observers) {
            if (ref.deref() === observer) {
                this.observers.delete(ref);
                return;
            }
        }
    }
    
    update(newValue: T): void {
        this.value = newValue;
        
        // Notify all live observers, prune dead ones
        for (const ref of this.observers) {
            const observer = ref.deref();
            if (observer) {
                observer.onUpdate(newValue);
            } else {
                this.observers.delete(ref);  // Clean up stale ref
            }
        }
    }
    
    getValue(): T {
        return this.value;
    }
}
 
// Usage
const observable = new WeakObservable<number>(0);
 
class DataDisplay implements Observer<number> {
    onUpdate(value: number): void {
        console.log(`Display updated: ${value}`);
    }
}
 
{
    // Create a display in an inner scope
    const display = new DataDisplay();
    observable.subscribe(display);
    observable.update(1);  // Display updated: 1
}
// display goes out of scope and can be collected
 
// After GC...
observable.update(2);  // No notification - observer was collected

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

import java.lang.ref.SoftReference;
import java.util.concurrent.ConcurrentHashMap;
 
public class SoftCache<K, V> {
    private final ConcurrentHashMap<K, SoftReference<V>> cache = 
        new ConcurrentHashMap<>();
    
    private final Function<K, V> loader;
    
    public SoftCache(Function<K, V> loader) {
        this.loader = loader;
    }
    
    public V get(K key) {
        SoftReference<V> ref = cache.get(key);
        V value = (ref != null) ? ref.get() : null;
        
        if (value == null) {
            // Cache miss or soft ref was cleared
            value = loader.apply(key);
            cache.put(key, new SoftReference<>(value));
        }
        
        return value;
    }
    
    public void invalidate(K key) {
        cache.remove(key);
    }
    
    public void clear() {
        cache.clear();
    }
    
    // Optional: periodic cleanup of cleared references
    public void cleanup() {
        cache.entrySet().removeIf(entry -> entry.getValue().get() == null);
    }
}
 
// Usage for expensive-to-create objects
SoftCache<String, BufferedImage> imageCache = new SoftCache<>(
    path -> ImageIO.read(new File(path))
);
 
BufferedImage img = imageCache.get("/path/to/large/image.png");
// Image is cached. Under memory pressure, JVM will clear
// soft references before throwing OutOfMemoryError.

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
62
63
64
65
66

// ❌ PITFALL: Assuming immediate collection
function buggyCode(): void {
    let obj = { data: 'important' };
    const weak = new WeakRef(obj);
    
    obj = null;  // Clear strong reference
    
    // WRONG: Object may still exist!
    if (weak.deref()) {
        console.log('This might still print!');
    }
}
 
// ❌ PITFALL: Creating strong ref in finalization (resurrection)
const registry = new FinalizationRegistry((heldValue) => {
    // DON'T DO THIS - creates a new strong reference
    globalCache.set('resurrected', heldValue);  // BAD!
});
 
// ❌ PITFALL: WeakMap with primitive-like keys
const badCache = new WeakMap();
// badCache.set('string-key', value);  // ERROR: Invalid value as key
 
// Instead, use a wrapper or regular Map with manual cleanup
const goodCache = new Map<string, { value: any; expiry: number }>();
 
// ❌ PITFALL: Assuming finalization for cleanup
class BadResource {
    private handle: number;
    
    constructor() {
        this.handle = acquireHandle();
        // NO! Don't rely on this for cleanup
        registry.register(this, this.handle);
    }
    
    // process.exit() = handle leaked!
}
 
// ✅ CORRECT: Explicit disposal with finalization as backup
class GoodResource implements Disposable {
    private handle: number;
    private disposed = false;
    
    constructor() {
        this.handle = acquireHandle();
        // Finalization is BACKUP, not primary
        registry.register(this, this.handle, this);
    }
    
    dispose(): void {
        if (this.disposed) return;
        this.disposed = true;
        
        registry.unregister(this);  // Cancel finalization
        releaseHandle(this.handle);
    }
    
    [Symbol.dispose](): void {
        this.dispose();
    }
}
 
// Usage with 'using' (TypeScript 5.2+)
using resource = new GoodResource();
// Automatically disposed at end of scope

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

import weakref
from weakref import WeakValueDictionary, WeakSet
 
# Basic weak reference
class ExpensiveObject:
    def __init__(self, name):
        self.name = name
        print(f"Created {name}")
    
    def __del__(self):
        print(f"Deleted {self.name}")
 
obj = ExpensiveObject("original")
weak = weakref.ref(obj)
 
print(weak())  # <ExpensiveObject object>
 
del obj
# After gc.collect()...
print(weak())  # None
 
# Callback on collection
def callback(ref):
    print("Object was collected!")
 
obj2 = ExpensiveObject("with callback")
weak2 = weakref.ref(obj2, callback)
del obj2  # Prints "Object was collected!"
 
# WeakValueDictionary - values held weakly
cache = WeakValueDictionary()
 
obj3 = ExpensiveObject("cached")
cache["key"] = obj3
 
print(cache.get("key"))  # <ExpensiveObject object>
 
del obj3
import gc; gc.collect()
 
print(cache.get("key"))  # None (entry removed automatically)
 
# WeakSet - members held weakly
tracked = WeakSet()
obj4 = ExpensiveObject("tracked")
tracked.add(obj4)
print(obj4 in tracked)  # True
 
del obj4
gc.collect()
print(len(tracked))  # 0