Menene GVL kuma yaya concurrency ke aiki a Ruby?

Question

Accepted Answer

The **GVL** (Global VM Lock, formerly GIL) in MRI Ruby allows only **one thread to execute Ruby code at a time** — so threads don't provide true CPU parallelism. But the GVL is **released during I/O**, so threads *do* help for I/O-bound work. For CPU parallelism, you use multiple processes. This mirrors Python's GIL situation.

## The GVL: one thread runs Ruby code at a time

```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 — good for 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 help for I/O-bound work (network, file, DB) because the GVL is released during the wait, letting other threads run. They do **not** speed up CPU-bound work (the GVL serializes Ruby execution).

## Processes — for 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
```

For CPU-bound parallelism, use **multiple processes** (each with its own GVL/interpreter) — `fork`, the `parallel` gem, or running multiple worker processes (how Rails servers like Puma scale).

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

## Me yasa hakan yana da mahimmanci

Tunani da GVL da Ruby concurrency yana da mahimmanci — kuma yawan jita-jita — ilimi domin gina Ruby aikace-aikace da kyau, kamar yanayin Python GIL.

Hankalin asali shine cewa MRI Ruby's **GVL yana ba da damar hanyoyi guda kawai don aiwatar da Ruby code a lokaci gida**, don haka hanyoyi ba sa ba da CPU parallelism — batu na yawan gida.

Mai alhakin mahimmanci, GVL yana **bubuguwar lokacin I/O**, wanda ke nufin tunadwar concurrency daidai ya dogara ga aikace-aikace: **hanyoyi suna aiki masu kyau para ga I/O-bound tasks** (network calls, file/database access — inda GVL yana bubuguwa lokacin jira, ba da damar hanyoyi tsaiko), amma **CPU-bound parallelism yana bukatar hanyoyi da yawa** (kowane yana da nasu GVL, samun ainihin parallelism a cikin cores — ta hanyar `fork`, the `parallel` gem, ko hanyoyi da yawa, wanda ne yake yiwuwa Rails servers sune).

Ba fahimi da GVL yana haifar da mavatsanan concurrency code (misali amfani hanyoyi ga CPU-heavy aikace-aikace da sa zata kusan.

Sani da I/O-vs-CPU yanke shawara (hanyoyi don I/O concurrency, hanyoyi don CPU parallelism), zamani kayan (Ractors don jashi na ainihin parallelism, Fibers/async don babbar I/O cooperative concurrency, background job processors kamar Sidekiq), kuma cewa jiya maimaitawa (JRuby, TruffleRuby) ba su da GVL yana muhimmanci don rubuta concurrent Ruby wanda ya aiki. Sanin concurrency yana da kowa bukawa kuma GVL yana kaida daidai kusani tunadwar saunin sanin — me yasa hanyoyi ba za su tsara CPU aiki, cewa suna taimaka don I/O, kuma cewa hanyoyi yana bukatar don CPU parallelism — yana da mahimmanci babbar mataki ilimi wanda ke kawar gida juyu kuma shine gama jita-jita batu wanda yake nufin fahimi Ruby concurrency model da nasu GVL matsala.