Mi a GVL és hogyan működik a párhuzamosság a Ruby-ban?

Question

Accepted Answer

A **GVL** (Global VM Lock, korábbi nevén GIL) az MRI Ruby-ban csak **egy szál hajthat végre Ruby kódot egyszerre** — így a szálak nem biztosítanak igazi CPU párhuzamosságot. A GVL azonban **felszabadul az I/O alatt**, így a szálak *valóban* segítenek az I/O-kötött munka esetén. CPU párhuzamossághoz több folyamatot használsz. Ez tükrözi a Python GIL-helyzetét.

## A GVL: egyszerre csak egy szál futtatja a Ruby kódot

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

## Szálak — jók az I/O-kötött párhuzamossághoz

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

A szálak segítenek az I/O-kötött munka esetén (hálózat, fájl, DB), mert a GVL felszabadul a várakozás során, lehetővé téve más szálak futtatását. Nem gyorsítanak fel CPU-kötött munka esetén (a GVL szerializálja a Ruby futtatást).

## Folyamatok — CPU-kötött párhuzamossághoz

```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-kötött párhuzamossághoz **több folyamatot** használj (mindegyik a saját GVL-jével/interpreterével) — `fork`, a `parallel` gem, vagy több worker folyamat futtatása (ahogy a Rails szerverek, például a Puma skálázódnak).

## Modern párhuzamossági eszközök

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

## Miért fontos

A GVL megértése és a Ruby párhuzamossága fontos — és gyakran félreértett — ismeret a hatékony Ruby alkalmazások építéséhez, hasonlóan a Python GIL helyzetéhez.

A kulcsmeglátás az, hogy az MRI Ruby **GVL csak egy szálat engedélyez a Ruby kód futtatásához egyszerre**, így a szálak *nem* biztosítanak CPU párhuzamosságot — ez egy gyakori zavaros pont.

Kritikusan fontos, hogy a GVL **felszabadul az I/O alatt**, ami azt jelenti, hogy a helyes párhuzamossági megközelítés a munkaterheléstől függ: **a szálak jól működnek az I/O-kötött feladatokhoz** (hálózati hívások, fájl/adatbázis hozzáférés — ahol a GVL felszabadul a várakozások során, lehetővé téve a szálak átfedését), de **CPU-kötött párhuzamossághoz több folyamatra van szükség** (mindegyik a saját GVL-jével, igazi párhuzamosságot érve el a magok között — a `fork`-on, a `parallel` gem-en vagy több worker folyamaton keresztül, amit a Rails szerverek így skáláznak).

A GVL félreértése hatástalan párhuzamossági kódhoz vezet (pl. szálak használata CPU-intenzív munkához, gyorsulást várva).

A I/O-vs-CPU döntés ismerete (szálak az I/O párhuzamossághoz, folyamatok a CPU párhuzamossághoz), modern eszközök (Ractors a kísérleti igazi párhuzamossághoz, Fibers/async a nagy I/O kooperatív párhuzamossághoz, háttérkiszolgáló folyamatok, mint a Sidekiq), és az, hogy az alternatív implementációk (JRuby, TruffleRuby) nem rendelkeznek GVL-lel, fontos az olyan párhuzamos Ruby írásához, amely valóban teljesít.

Mivel a párhuzamosság közös igény és a GVL alapvetően meghatározza a helyes megközelítést, a megértése — miért nem párhuzamosítja a szálak a CPU munkát, hogy segítenek az I/O esetén, és hogy folyamatok szükségesek a CPU párhuzamossághoz — fontos senior szintű ismeret, amely megelőz egy gyakori hibát és közös interjú téma, amely tükrözi a Ruby párhuzamossági modelljének és annak GVL korlátjának megértését.