Ruby-ல் GVL என்றால் என்ன மற்றும் concurrency எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**GVL** (Global VM Lock, முன்னர் GIL) MRI Ruby-ல் **ஒரு நேரத்தில் ஒரே ஒரு thread-ஐ Ruby code செயல்படுத்த அனுமதிக்கிறது** — எனவே threads உண்மையான CPU parallelism வழங்காது. ஆனால் GVL **I/O சமயத்தில் விடுவிக்கப்படுகிறது**, எனவே threads *உண்மையில்* I/O-bound வேலைக்கு உதவுகின்றன. CPU parallelism-க்கு, நீங்கள் பல processes பயன்படுத்துகிறீர்கள். இது Python-ன் GIL சூழ்நிலையை பிரதிபலிக்கிறது.

## GVL: ஒரு நேரத்தில் ஒரே ஒரு thread Ruby code-ஐ இயக்குகிறது

```text
MRI (the standard Ruby) has a GLOBAL VM LOCK:
  → only ONE thread executes Ruby code at any instant (no CPU parallelism from threads)
  → BUT the GVL is RELEASED during blocking I/O (network, file, DB)
So: threads help for I/O-bound work, NOT for CPU-bound work.
```

## Threads — I/O-bound concurrency-க்கு நல்லது

```ruby
# ✅ I/O-bound — threads overlap waiting (GVL released during I/O) → real benefit
threads = urls.map do |url|
  Thread.new { fetch(url) }      # while one waits on the network, others proceed
end
threads.each(&:join)

# ❌ CPU-bound — threads do NOT speed this up (GVL serializes Ruby execution)
threads = data.map { |d| Thread.new { heavy_computation(d) } }  # no speedup
```

Threads I/O-bound வேலைக்கு உதவுகின்றன (network, file, DB) ஏனெனில் GVL காத்திருக்கும் போது விடுவிக்கப்படுகிறது, மற்ற threads-ஐ இயக்க அனுமதிக்கிறது. அவை CPU-bound வேலைக்கு (GVL Ruby செயல்பாட்டை serializes செய்கிறது) **வேகத்தை அளிக்க மாட்டாது**.

## Processes — CPU-bound parallelism-க்கு

```ruby
# ✅ CPU-bound parallelism → use multiple PROCESSES (each has its own GVL)
# fork, or gems like Parallel:
results = Parallel.map(data, in_processes: 4) { |d| heavy_computation(d) }
# → 4 separate processes, true parallelism across cores
```

CPU-bound parallelism-க்கு, **பல processes** பயன்படுத்தவும் (ஒவ்வொன்றும் அதன் சொந்த GVL/interpreter உடன்) — `fork`, `parallel` gem, அல்லது பல worker processes இயக்குதல் (Puma போன்ற Rails servers எவ்வாறு scale செய்கிறது).

## நவீன concurrency tools

```text
✓ Ractors (Ruby 3) — actor-model parallelism that CAN run Ruby in parallel (no shared GVL
  per Ractor) — experimental, true parallelism
✓ Fibers / async gem — lightweight cooperative concurrency for high-I/O workloads
✓ Background jobs (Sidekiq) — offload work to separate worker processes
Note: alternative Ruby implementations (JRuby, TruffleRuby) have NO GVL → true thread parallelism
```

## இது ஏன் முக்கியமானது

GVL மற்றும் Ruby concurrency ஐ புரிந்துகொள்வது முக்கியமான — மற்றும் அடிக்கடி தவறாக புரிந்துகொள்ளப்படும் — செயல்திறனான Ruby applications கட்டுவதற்கான அறிவு, Python-ன் GIL சூழ்நிலையைப் போல.

மূল insight என்பது MRI Ruby-ன் **GVL ஒரு நேரத்தில் ஒரே ஒரு thread-ஐ Ruby code செயல்படுத்த அனுமதிக்கிறது**, எனவே threads CPU parallelism வழங்க *வேண்டாம்* — குழப்பத்தின் பொதுவான புள்ளி.

আলোচনையில், GVL **I/O சமயத்தில் விடுவிக்கப்படுகிறது**, இதன் பொருள் சரியான concurrency அணுகுமுறை workload-ஐ சார்ந்துள்ளது: **threads I/O-bound tasks-க்கு நன்றாக செயல்படுகின்றன** (network calls, file/database access — GVL காத்திருப்புகளின் போது விடுவிக்கப்படுகிறது, threads-ஐ overlap செய்ய அனுமதிக்கிறது), ஆனால் **CPU-bound parallelism பல processes தேவை** (ஒவ்வொன்றும் அதன் சொந்த GVL உடன், cores-க்கு உண்மையான parallelism அடையும் — `fork`, `parallel` gem, அல்லது பல worker processes மூலம், இது Rails servers எவ்வாறு scale செய்கிறது).

GVL பற்றிய தவறான புரிதல் பயனற்ற concurrency code-க்கு வழிவகுக்கிறது (எ.கா. CPU-heavy வேலைக்கு threads பயன்படுத்துதல் speedup எதிர்பார்க்கின்றது).

I/O-vs-CPU decision ஐ அறிந்திருத்தல் (I/O concurrency-க்கு threads, CPU parallelism-க்கு processes), நவீன tools (experimental true parallelism-க்கு Ractors, high-I/O cooperative concurrency-க்கு Fibers/async, Sidekiq போன்ற background job processors), மற்றும் alternative implementations (JRuby, TruffleRuby) GVL இல்லாமல் இருப்பது concurrent Ruby எழுதுவதற்கு முக்கியமாகும் அது உண்மையில் செயல்படுகிறது.

Concurrency பொதுவான தேவை மற்றும் GVL அடிப்படையாக சரியான அணுகுமுறையை உருவாக்குகிறது, அதை புரிந்துகொள்வது — threads CPU வேலைக்கு parallelism செய்ய மாட்டாது, அவை I/O-க்கு உதவுகின்றன, மற்றும் processes CPU parallelism-க்கு தேவைப்படுகிறது — முக்கியமான senior-level அறிவு அது அடிக்கடி விளைவை தடுக்கிறது மற்றும் Ruby-ன் concurrency model மற்றும் அதன் GVL constraint பற்றிய புரிதலை பிரதிபலிக்கும் பொதுவான interview topic.