Ruby எவ்வாறு மெमோரி மற்றும் garbage collection ஐ நிர்வகிக்கிறது?

Question

Accepted Answer

Ruby **தன்னியக்கமாக** **garbage collector (GC)** மூலம் மெமொரியை நிர்வகிக்கிறது, இது இனி குறிப்பிடப்படாத பொருட்களை மீட்டெடுக்கிறது. நவீன Ruby (MRI) **generational, incremental mark-and-sweep** collector ஐ compaction உடன் பயன்படுத்துகிறது. இது performance மற்றும் நீண்ட கால பயன்பாட்டு பயன்பாடுகளில் மெமொரி சிக்கல்களைக் கண்டறிய உதவுகிறது.

## தன்னியக்க 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** அணுகுமுறை (தளிர் பொருட்களை அடிக்கடி மற்றும் மலிவாக சேகரிக்கிறது, பழைய பொருட்களை அரிதாக) அதை திறமையாக்குகிறது, மற்றும் incremental collection நிறுத்தத்தை குறைக்கிறது.

## 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.
```

## மெமொரி கசிவு இன்னும் நடக்கிறது (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 இணைய சேவையகங்கள் போன்றவை, பின்னணி செயல்களாளிகள்) பொருட்டு மெமொரி நடத்தை நிலைத்தன்மை மற்றும் performance விஷயங்களுக்கு.

GC நீங்களை கைமுறை மெமொரி நிர்வாகத்திலிருந்து விடுவிக்கிறது (ஒரு பெரிய productivity நன்மை), ஆனால் *எவ்வாறு* இது செயல்படுகிறது என்பதைப் புரிந்துகொள்வது performance சரிசெய்தலுக்கும் மெமொரி சிக்கல்களைக் கண்டறிய உதவுகிறது.

நவீன Ruby **generational, incremental, mark-and-sweep** collector ஐ பயன்படுத்துகிறது (தளிர் பொருட்களை அடிக்கடி மற்றும் மலிவாக சேகரிக்கிறது, பழைய பொருட்களை அரிதாக, வேலை பரவ்ய நிறுத்தத்தை குறைக்க) என்பதை அறிந்திருப்பது GC நடத்தை மற்றும் அழுத்தம் பற்றி நினைக்க உதவுகிறது, மற்றும் அதிக பொருள் ஒதுக்கம் GC overload ஐ அதிகரிக்கிறது (எனவே தேவையற்ற ஒதுக்கம் குறைப்பது performance மேம்படுத்தலாம்).

க்রிটிக்கல்லி, **மெமொரி கசிவு GC இருந்தும் நடக்கிறது** என்பதை புரிந்துகொள்வது — GC *மட்டுமே* unreachable பொருட்களை மீட்டெடுக்கிறது, எனவே "கசிவுகள்" unintended **lingering references** இலிருந்து வருகிறது (global அல்லது class-level collections இன்னும் வளர்கிறது, unbounded caches போன்றவை; நீண்ட கால பொருட்களில் வைத்திருக்கும் references; closures ஆல் जीवனுள் வைக்கப்பட்ட பெரிய பொருட்கள்) — நீண்ட கால Ruby processes இல் plagues மெமொரி வளர்ச்சிக் கண்டறிய மற்றும் சரிசெய்ய முக்கியமாகும் (ஒரு உண்மை, பொதுவான operational சிக்கல்).

GC இன் நடத்தை, இதை பரிசோதிப்பது எப்படி (`GC.stat`, `ObjectSpace`), சரிசெய்தல் விருப்பங்கள், மற்றும் குறிப்பாக மெமொரி வளர்ச்சির பொதுவான காரணங்கள் (retained references) ஐ அறிந்திருப்பது performant, நிலையான Ruby பயன்பாட்டு செயல்படுத்தலுக்கு மதிப்புமிக்கது.

Ruby பயன்பாட்டு (குறிப்பாக Rails சேவையகங்கள்) நீண்ட காலங்களுக்கு இயங்கும் மற்றும் retained references இலிருந்து மெமொரி கசிவு ஒரு அடிக்கடி உண்மை-உலக சிக்கல் என்பதால், Ruby இன் GC ஐ புரிந்துகொள்வது — அதன் generational mark-and-sweep மாடல், அது reachable பொருட்களை மீட்டெடுக்க முடியாது, மற்றும் மெமொரி வளர்ச்சியின் காரணங்கள் — production Ruby இல் மெமொரி சிக்கல்களைக் கண்டறிய மற்றும் சரிசெய்ய கூடிய developers ஐ வேறுபடுத்துவது, performance மற்றும் நிலைத்தன்மெக்கு முக்கியமான senior-level அறிவு, மற்றும் performance-focused roles க்கு பொருந்தக்கூடிய விஷயம்.