Methods of Garbage Collection in JavaScript - 面试题

JavaScript garbage collection is an automatic memory management mechanism that eliminates the need for developers to manually release allocated memory. In JavaScript, garbage collection primarily employs the following methods:

1. Mark and Sweep

This is the most common garbage collection algorithm. When a variable enters the scope, it is marked as active. When a variable leaves the scope, it is marked as inactive. The garbage collector runs periodically, checking all variables and the objects they reference to determine if they are still reachable. If a variable is no longer reachable and no other variables reference it, the memory it occupies is reclaimed.

Example:

javascript
function processData() {
    var data = { /* large data */ };
    // Process data
}

processData();
// After processData executes, the data variable leaves the scope and becomes unreachable, marked for reclamation.

2. Reference Counting

Reference counting is another garbage collection mechanism. In this system, each value has a reference count indicating how many variables or resources reference it. If the reference count drops to zero, the value is no longer needed, and its memory can be reclaimed. A drawback is reference cycles: if two objects reference each other, even if they are no longer needed, the reference count remains non-zero, leading to memory leaks.

Example:

javascript
function referenceCycle() {
    var objectA = {};
    var objectB = {};

    objectA.other = objectB;
    objectB.other = objectA;
}

referenceCycle();
// Even after referenceCycle executes, objectA and objectB are mutually referenced, so their reference counts remain non-zero, causing memory leaks.

3. Generational Collection

Generational collection is based on the assumption that objects have varying lifetimes, dividing them into two groups: "young generation" and "old generation." Newly created objects belong to the young generation. If an object survives long enough, it is promoted to the old generation. Typically, the young generation uses the mark-copy algorithm, while the old generation uses mark-sweep or mark-compact algorithms.

4. Mark-Compact

This method improves upon mark-sweep. In the mark phase, all active objects are marked. Then, in the compact phase, all active objects are moved to one end of the memory, and the memory beyond the boundary is cleared.

5. Incremental Collection

Incremental collection divides garbage collection into small fragments, processing only a portion of objects at a time, then pausing to allow the program to continue executing. This reduces pause times during garbage collection.

6. Idle-time Collection

Some JavaScript engines utilize CPU idle time to perform garbage collection, minimizing interference with program execution efficiency.