Understanding Garbage Collection in JavaScript and Beyond

Recently, I was asked in a technical interview how different programming languages ​​handle garbage collection. This was a surprising yet refreshing question, and it really piqued my interest - I'd never encountered such an in-depth discussion of memory management in an interview before. I like this question and would like to explore this topic further in a blog post.

---

Efficient memory management is critical for high-performance applications. Garbage Collection (GC) Ensures automatic recycling of unused memory to prevent memory leaks and crashes. In this article, we'll focus on how garbage collection works in JavaScript, explore other methods used in programming languages, and provide examples to illustrate these concepts.

---

What is garbage collection?

Garbage collection is the process of reclaiming memory occupied by objects that are no longer used. Languages ​​with automatic garbage collection abstract this process so developers don't have to manually manage memory. For example, JavaScript uses a tracking garbage collector, while other languages ​​use different techniques.

---

Garbage collection in JavaScript

JavaScript relies on the tracking garbage collection method, specifically the mark-sweep algorithm. Let’s break it down:

1. Mark-clear algorithm

This algorithm determines which objects in memory are "reachable" and frees those that are unreachable:

1. Mark stage:
   • Start from a "root" object (for example, window in a browser or the global object in Node.js).
   • Iterate through all objects reachable from these root objects and mark them as "alive".
2. Clear Phase:
   • Scan the heap and release objects that are not marked as reachable.

Example:

function example() {
  let obj = { key: "value" }; // obj 可达
  let anotherObj = obj; // anotherObj 引用 obj

  anotherObj = null; // 引用计数减少
  obj = null; // 引用计数减少到 0
  // obj 现在不可达，将被垃圾回收
}

2. Generational garbage collection

Modern JavaScript engines (such as V8 in Chrome/Node.js) use Generational GC to optimize garbage collection. Memory is divided into:

• New Generation: Short-lived objects (such as function scope variables) are stored here and collected frequently.
• Old generation: Long-lived objects (such as global variables) are stored here and collected less frequently.

Why is generational GC more efficient?

• Most objects in JavaScript are ephemeral and can be collected quickly.
• Long-lived objects are moved to the old generation, reducing the need for frequent scans.

---

Other garbage collection strategies

Let’s explore how other languages ​​handle garbage collection:

<.> 1. Reference counting

How many references to the reference counting are directed to an object. When the reference count is reduced to 0, the object will be released.

<点> Advantages:

Simple and immediately recycled memory.

• Before predicting.
<缺> Disadvantages:

<循> Circular reference

: If the two objects are referenced with each other, their counts will never reach 0.

• <示> Example: (python reference count)

<.> 2. Manual memory management

<<> C

function example() {
  let obj = { key: "value" }; // obj 可达
  let anotherObj = obj; // anotherObj 引用 obj

  anotherObj = null; // 引用计数减少
  obj = null; // 引用计数减少到 0
  // obj 现在不可达，将被垃圾回收
}

and

C Language requires developers to express and release memory.

<示> Example:

(C memory management) <点> Advantages:

Completely control the use of memory.

a = []
b = []
a.append(b)
b.append(a)
# 这些对象相互引用，但不可达；现代 Python 的循环收集器可以处理这种情况。

<缺> Disadvantages:

Memory leaks (forgot to release memory) and suspended pointers (prematurely release memory).

<.> 3. Tracking garbage recycling with a circular collector

Some languages ​​(such as Python) combine the reference count

and

cycle detection
• to treat the cycle reference.

The cycle collector scan the object regularly to detect the cycle (the mutual reference object group that cannot be accessed from the root object). Once the cycle is found, the collector will destroy it and recycle memory. The cycle collector solves the biggest disadvantage (cycle reference) of pure reference counting. They increase additional expenses, but make sure they do not cause memory leaks due to cycle.

<.> 4. Rust's borrowing inspection device (no GC) Rust uses a different method,

completely avoiding garbage recycling

. On the contrary, RUST uses <> borrowing the inspection device
• to enforce strict ownership rules:
<权> 🎜

: There is only one owner at a time at a time.

<借> Borrow : You can borrow reference (uncharacteristic or variable), but only allow only one variable reference to prevent

data competition . <命> The life cycle

: When the compiler's inference value exceeds the scope of the scope and automatically releases the memory.

• This system ensures that memory is safe and does not require traditional GCs, so that Rust has the performance advantage of manual memory management, while helping to avoid common errors such as suspended pointers.
• Supplementary explanation. #Data competition occurs in concurrent or parallel programming. When two or more threads (or processes) access the same memory position at the same time, and at least one thread is written into this position. Because there is no mechanism (such as locks or atomic operations) to coordinate these concurrency access, the final state of the shared data may be unpredictable and inconsistent -thereby errors that are difficult to find.

  ---

  <垃> The garbage recycling strategy compares

  <<> ---

  方法	语言	优点	缺点
  引用计数	早期的 Python，Objective-C	立即回收，易于实现	循环引用失效
  追踪式（标记-清除）	JavaScript，Java	处理循环引用，对于大型堆效率高	停止世界暂停
  分代式 GC	JavaScript，Java	针对短暂的对象进行了优化	实现更复杂
  手动管理	C，C	完全控制	容易出错，需要仔细处理
  混合式（引用计数 循环收集器）	现代 Python	两全其美	仍然需要定期的循环检测
  借用检查器	Rust	无需 GC，防止数据竞争	学习曲线较陡峭，所有权规则

  JavaScript How to deal with common scenes

  <循> Circular reference

  JavaScript's tracking garbage recovery can handle the cyclic reference:

  <件> Event monitoring and closure

  function example() {
    let obj = { key: "value" }; // obj 可达
    let anotherObj = obj; // anotherObj 引用 obj
  
    anotherObj = null; // 引用计数减少
    obj = null; // 引用计数减少到 0
    // obj 现在不可达，将被垃圾回收
  }

  If the incident monitor is not cleaned correctly, it may accidentally cause memory leakage:
  <点> Summary

  a = []
  b = []
  a.append(b)
  b.append(a)
  # 这些对象相互引用，但不可达；现代 Python 的循环收集器可以处理这种情况。

  ---

  JavaScript uses

  tracked garbage recychers from the algorithm

  from mobilizing management memory.
  1. Divided GC Optimize performance by paying attention to the short object. Different strategies use other languages:
  Reference counting
  2. : simple but easy to occur. Manual management
  : fully controlled but easy to make mistakes.
  3. Mixed method
     • : Combined with strategies to obtain better performance. Rust's borrowing inspection device
     : No GC, but there are strict ownership rules.
     Pay attention to the potential memory leaks in JavaScript, especially in closures and event monitoring.
     • This is an excellent opportunity to understand language for garbage recycling strategies. In my opinion, understanding the working principle of garbage recycling can not only help you write efficient code, but also allow you to effectively debug the errors related to memory.
     • Reference
  JavaScript and memory management: MDN document
  v8 garbage recycling: V8 blog about garbage recycling

  Rust's ownership: Rust programming language books

  ---

  Java garbage recycling: Oracle document

  Python's GC: Python GC module

  The above is the detailed content of Understanding Garbage Collection in JavaScript and Beyond. For more information, please follow other related articles on the PHP Chinese website!