GVL ni nini na concurrency inafanyaje kazi katika Ruby?

Question

Accepted Answer

**GVL** (Global VM Lock, awali GIL) katika MRI Ruby huruhusu **thread moja tu kuendesha code ya Ruby kwa wakati mmoja** — hivyo threads hazitoi CPU parallelism halisi. Lakini GVL **huachiliwa wakati wa I/O**, hivyo threads *zinasaidia* kwa kazi za I/O-bound. Kwa CPU parallelism, hutumia processes nyingi. Hii inafanana na hali ya GIL ya Python.

## GVL: thread moja huendesha code ya Ruby kwa wakati mmoja

```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 — nzuri kwa concurrency ya I/O-bound

```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 zinasaidia kwa kazi za I/O-bound (network, file, DB) kwa sababu GVL huachiliwa wakati wa kusubiri, ikiruhusu threads nyingine kuendesha. **Hazi**ongezi kasi ya kazi za CPU-bound (GVL huweka mfululizo utekelezaji wa Ruby).

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

Kwa CPU-bound parallelism, tumia **processes nyingi** (kila moja na GVL/interpreter yake) — `fork`, gem ya `parallel`, au kuendesha worker processes nyingi (jinsi servers za Rails kama Puma zinavyopanuka).

## Zana za kisasa za concurrency

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

## Kwa nini ni muhimu

Kuelewa GVL na concurrency ya Ruby ni maarifa muhimu — na yanayoeleweka vibaya mara kwa mara — kwa kujenga applications za Ruby zenye utendaji, sawa na hali ya GIL ya Python.

Ufahamu muhimu ni kwamba **GVL ya MRI Ruby huruhusu thread moja tu kuendesha code ya Ruby kwa wakati mmoja**, hivyo threads *hazitoi* CPU parallelism — nukta ya kawaida ya kuchanganyikiwa.

Kwa umuhimu, GVL **huachiliwa wakati wa I/O**, ambayo ina maana mbinu sahihi ya concurrency inategemea aina ya kazi: **threads hufanya kazi vizuri kwa kazi za I/O-bound** (network calls, file/database access — ambapo GVL huachiliwa wakati wa kusubiri, ikiruhusu threads kuingiliana), lakini **CPU-bound parallelism inahitaji processes nyingi** (kila moja na GVL yake, ikifikia parallelism halisi kwenye cores — kupitia `fork`, gem ya `parallel`, au worker processes nyingi, ambayo ndiyo jinsi servers za Rails zinavyopanuka).

Kuelewa GVL vibaya husababisha code ya concurrency isiyo na ufanisi (k.m. kutumia threads kwa kazi nzito za CPU ukitarajia kuongezeka kwa kasi).

Kujua uamuzi wa I/O-dhidi-ya-CPU (threads kwa I/O concurrency, processes kwa CPU parallelism), zana za kisasa (Ractors kwa parallelism halisi ya kimajaribio, Fibers/async kwa cooperative concurrency ya I/O-juu, processors za background jobs kama Sidekiq), na kwamba implementations mbadala (JRuby, TruffleRuby) hazina GVL ni muhimu kwa kuandika Ruby ya concurrent inayofanya kazi kweli.

Kwa kuwa concurrency ni hitaji la kawaida na GVL huunda kimsingi mbinu sahihi, kuielewa — kwa nini threads haziparallelize kazi za CPU, kwamba zinasaidia kwa I/O, na kwamba processes zinahitajika kwa CPU parallelism — ni maarifa muhimu ya kiwango cha senior yanayozuia kosa la kawaida na ni mada ya mahojiano inayojirudia inayoonyesha uelewa wa model ya concurrency ya Ruby na kizuizi chake cha GVL.