Cad is ea an GVL agus conas a oibríonn comhthreadú i Ruby?

Question

IT Interview Practice · 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.

## An GVL: snáithe amháin ag rith cód Ruby ag an am

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

## Snáithí — go maith do chomhthreadú teoranta ar I/O

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

Bíonn snáithí úsáideach do obair theoranta ar I/O (gréasán, comhad, DB) toisc go scaoiltear an GVL le linn an bhraistint, rud a cheadaíonn do snáithí eile a rith. Níl **ní** spréacharnach ar obair bhunúsach ar CPU (déanann an GVL sreacharnach ar dhíorthú Ruby).

## Próisis — do chomhthreadú parailléal ar bhunúsach CPU

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

Do chomhthreadú parailléal ar CPU, bain úsáid as **ilpróisis** (gach ceann lena GVL/intearpréadóir féin) — `fork`, an `parallel` gem, nó rás iolrach a bheith ar foluain (conas a dhéanann freastalaí Rails cosúil le Puma scála).

## Uirlisí comhthreadu nua-aimseartha

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

## Cén fáth a bhíonn tábhacht ann

Tá tuiscint ar an GVL agus ar chomhthreadú Ruby tábhachtach — agus go minic a thuigtear go mícheart — eolas do thógáil feidhmchéimí Ruby, cosúil le staid GIL Python.

Is é an léargas ríthábhachtach ná go bhfuil **GVL MRI Ruby a cheadaíonn snáithe amháin amháin a dhíorthú cód Ruby ag an am**, mar sin ní **soláthraíonn snáithí comhthreadú CPU** — pointe coisiochta coitianta.

Go criticiúil, scaoiltear an GVL **le linn I/O**, rud a chiallaíonn go mbraitheann an cur chuige comhthreadu ceart ar an obair: **oibríonn snáithí go maith do ghnothaí teoranta ar I/O** (glaoigh gréasáin, rochtain ar chomhad/bhunachar — áit a scaoiltear an GVL le linn feitheamh, rud a cheadaíonn do snáithí a fhorluain), ach **éilíonn comhthreadu parailléal ar CPU iolpróisis** (gach ceann lena GVL féin, an fhíor-chomhthreadu a bhaint amach trasnán croíanna — trí `fork`, an `parallel` gem, nó iolrach próisis oibrí, ar an mbealach a dhéanann freastalaí Rails scála).

Tugann míthhuiscint ar an GVL ar chód comhthreadu éifeachtúil (e.g. snáithí a úsáid d'obair dhromchla CPU ag súil go bhfuil luathú ann).

Tá eolas ar an cinneadh I/O-vs-CPU (snáithí do comhthreadu I/O, próisis do chomhthreadu CPU), uirlisí nua-aimseartha (Ractors do thréimhse fhíor-parailléal, Fibers/async do chomhthreadu iomlán ardaithe I/O, próiseasúirí gnothaí cúlra cosúil le Sidekiq), agus go bhfuil cur i bhfeidhm malarta (JRuby, TruffleRuby) gan an GVL tábhachtach do scríobh comhthreadu Ruby a fheidhmíonn i ndáiríre.

De bharr go bhfuil comhthreadu ina riachtanas coitianta agus go ndéanann an GVL an cur chuige ceart a bheth, tá tuiscint air — cén fáth nach bhfuil snáithí ag parailléal ar obair CPU, go gcabhraíonn siad do I/O, agus go bhfuil próisis de dhíth ar chomhthreadu CPU — tábhachtach eolas ar leibhéal shinsir a bhac ar earráid dheas-bhailí agus ar ábhar agallamh coitianta a léiríonn tuiscint ar mhúnla comhthreadu Ruby agus ar a srian GVL.

An GVL: snáithe amháin ag rith cód Ruby ag an am

Snáithí — go maith do chomhthreadú teoranta ar I/O

Próisis — do chomhthreadú parailléal ar bhunúsach CPU

Uirlisí comhthreadu nua-aimseartha

Cén fáth a bhíonn tábhacht ann

Ceisteanna gaolmhara