Ruby ਮੈਮੋਰੀ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਬੰਧਿਤ ਕਰਦਾ ਹੈ ਅਤੇ garbage collection ਕਿਵੇਂ ਕਾਰਜ ਕਰਦੀ ਹੈ?

Question

Accepted Answer

Ruby ਮੈਮੋਰੀ ਨੂੰ **ਆਪਣੇ-ਆਪ** ਇੱਕ **garbage collector (GC)** ਦੇ ਜ਼ਰੀਏ ਪ੍ਰਬੰਧਿਤ ਕਰਦਾ ਹੈ ਜੋ ਉਹਨਾਂ ਚੀਜ਼ਾਂ ਨੂੰ ਮੁਕਤ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਕੋਈ reference ਨਹੀਂ ਰਿਹਾ। ਆਧੁਨਿਕ Ruby (MRI) ਇੱਕ **generational, incremental mark-and-sweep** collector ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ compaction ਹੈ। ਇਸ ਨੂੰ ਸਮਝਣਾ performance ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਚਲਣ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸਨਾਂ ਵਿੱਚ ਮੈਮੋਰੀ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਨਿਦਾਨ ਕਰਨ ਵਿੱਚ ਸਹਾਇਕ ਹੁੰਦਾ ਹੈ।

## Automatic garbage collection

```text
Ruby allocates objects on the heap; the GC reclaims those that are no longer REACHABLE
(referenced). You never free memory manually.

Modern MRI GC characteristics:
  ✓ Mark-and-sweep — marks reachable objects (from roots), sweeps unreachable ones
  ✓ Generational (since Ruby 2.1) — new objects collected often, old ones rarely
    (based on "most objects die young")
  ✓ Incremental — spreads GC work to reduce pause times
  ✓ Compacting (GC.compact, Ruby 2.7+) — reduces memory fragmentation
```

GC ਤੁਹਾਨੂੰ ਹੱਥੋ-ਹੱਥ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਤੋਂ ਮੁਕਤ ਕਰਦਾ ਹੈ। **generational** approach (ਬਚਿਆਂ ਦੀਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਅਕਸਰ ਅਤੇ ਸਸਤੀ ਕੀਮਤ 'ਤੇ ਇਕੱਠਾ ਕਰਨਾ, ਪੁਰਾਣੀਆਂ ਨੂੰ ਬਹੁਤ ਘੱਟ) ਇਸਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਬਣਾਉਂਦੀ ਹੈ, ਅਤੇ incremental collection pauses ਨੂੰ ਘਟਾਉਂਦੀ ਹੈ।

## Inspecting and tuning GC

```ruby
GC.stat                    # detailed GC statistics (counts, heap info)
GC.start                   # manually trigger a collection (rarely needed)
GC.compact                 # compact the heap (reduce fragmentation)
ObjectSpace.count_objects  # counts of objects by type (debugging)
# environment variables (RUBY_GC_*) tune heap growth, etc.
```

## Memory leaks ਅਜੇ ਵੀ ਹੁੰਦੇ ਹਨ (GC ਦੇ ਬਾਵਜੂਦ)

```ruby
# the GC frees only UNREACHABLE objects — "leaks" come from lingering references:
$global_cache = []
def process(item)
  $global_cache << item    # ❌ grows forever — never freed (still referenced)
end
```

```text
Common Ruby memory-growth causes:
  ✗ Global/class-level collections that only grow (caches, arrays)
  ✗ References held in long-lived objects (constants, class variables)
  ✗ Large objects kept alive by closures/blocks
→ The GC can't free reachable objects, so "leaks" = unintended retained references.
```

## ਇਹ ਮਾਤਰ ਕਿਉਂ ਅਹਿਮ ਹੈ

Ruby ਦੇ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਅਤੇ garbage collection ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਗਿਆਨ ਹੈ, ਖ਼ਾਸ ਕਰਕੇ **ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚਲਣ ਵਾਲੀਆਂ Ruby ਐਪਲੀਕੇਸਨਾਂ** ਲਈ (ਜਿਵੇਂ Rails ਵੈੱਬ ਸਰਵਰ, background workers) ਜਿੱਥੇ ਮੈਮੋਰੀ ਦਾ ਰਵੈਯਾ stability ਅਤੇ performance ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ।

ਜਦਕਿ GC ਤੁਹਾਨੂੰ ਹੱਥੋ-ਹੱਥ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਤੋਂ ਮੁਕਤ ਕਰਦਾ ਹੈ (ਇੱਕ ਵੱਡਾ ਉਤਪਾਦਨ ਲਾਭ), ਇਹ ਸਮਝਣਾ ਕਿ ਇਹ *ਕਿਵੇਂ* ਕਾਰਜ ਕਰਦਾ ਹੈ, performance tuning ਅਤੇ ਮੈਮੋਰੀ ਸਮੱਸਿਆਵਾਂ ਦਾ ਨਿਦਾਨ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਇਹ ਜਾਣਨਾ ਕਿ ਆਧੁਨਿਕ Ruby ਇੱਕ **generational, incremental, mark-and-sweep** collector ਵਰਤਦਾ ਹੈ (ਬਚਿਆਂ ਦੀਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਅਕਸਰ ਅਤੇ ਸਸਤੀ ਕੀਮਤ 'ਤੇ ਇਕੱਠਾ ਕਰਨਾ, ਪੁਰਾਣੀਆਂ ਨੂੰ ਬਹੁਤ ਘੱਟ, ਜਦਕਿ ਕੰਮ ਨੂੰ pauses ਘਟਾਉਣ ਲਈ ਫੈਲਾਉਣਾ) ਤੁਹਾਨੂੰ GC ਦੇ ਵਿਵਹਾਰ ਅਤੇ pressure ਬਾਰੇ ਸੋਚਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਕਿ ਜ਼ਿਆਦਾ object allocation GC overhead ਵਧਾਉਂਦਾ ਹੈ (ਇਸ ਲਈ ਅਨਾਵਸ਼ਯਕ allocations ਘਟਾਉਣਾ performance ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਸਕਦਾ ਹੈ)।

je ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ ਇਹ ਸਮਝਣਾ ਕਿ **ਮੈਮੋਰੀ leaks ਅਜੇ ਵੀ ਹੁੰਦੇ ਹਨ** GC ਦੇ ਬਾਵਜੂਦ — ਕਿਉਂਕਿ GC ਸਿਰਫ *unreachable* ਚੀਜ਼ਾਂ ਨੂੰ ਮੁਕਤ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ