Apakah GVL dan bagaimana concurrency berfungsi dalam Ruby?

Question

Accepted Answer

**GVL** (Global VM Lock, dahulunya GIL) dalam MRI Ruby membenarkan hanya **satu thread melaksanakan kod Ruby pada satu masa** — jadi thread tidak menyediakan keselarian CPU yang sebenar. Tetapi GVL **dilepaskan semasa I/O**, jadi thread *memang* membantu untuk kerja terikat-I/O. Untuk keselarian CPU, anda menggunakan berbilang proses. Ini mencerminkan situasi GIL Python.

## GVL: satu thread menjalankan kod Ruby pada satu masa

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

## Thread — baik untuk concurrency terikat-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
```

Thread membantu untuk kerja terikat-I/O (rangkaian, fail, DB) kerana GVL dilepaskan semasa menunggu, membolehkan thread lain berjalan. Ia **tidak** mempercepatkan kerja terikat-CPU (GVL mensiri pelaksanaan Ruby).

## Proses — untuk keselarian terikat-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
```

Untuk keselarian terikat-CPU, gunakan **berbilang proses** (setiap satu dengan GVL/interpreter sendiri) — `fork`, gem `parallel`, atau menjalankan berbilang proses worker (cara pelayan Rails seperti Puma menskala).

## Alat concurrency moden

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

## Mengapa ia penting

Memahami GVL dan concurrency Ruby ialah pengetahuan yang penting — dan kerap disalah faham — untuk membina aplikasi Ruby yang berprestasi, seperti situasi GIL Python.

Wawasan utama ialah **GVL MRI Ruby membenarkan hanya satu thread melaksanakan kod Ruby pada satu masa**, jadi thread *tidak* menyediakan keselarian CPU — satu poin kekeliruan yang lazim.

Yang kritikal, GVL **dilepaskan semasa I/O**, yang bermaksud pendekatan concurrency yang betul bergantung pada beban kerja: **thread berfungsi dengan baik untuk tugas terikat-I/O** (panggilan rangkaian, akses fail/pangkalan data — di mana GVL dilepaskan semasa menunggu, membolehkan thread bertindih), tetapi **keselarian terikat-CPU memerlukan berbilang proses** (setiap satu dengan GVL sendiri, mencapai keselarian sebenar merentas core — melalui `fork`, gem `parallel`, atau berbilang proses worker, iaitu cara pelayan Rails menskala).

Salah faham tentang GVL membawa kepada kod concurrency yang tidak berkesan (cth. menggunakan thread untuk kerja berat-CPU dengan harapan peningkatan kelajuan).

Mengetahui keputusan I/O-lawan-CPU (thread untuk concurrency I/O, proses untuk keselarian CPU), alat moden (Ractor untuk keselarian sebenar eksperimen, Fiber/async untuk concurrency kooperatif I/O tinggi, pemproses background job seperti Sidekiq), dan bahawa pelaksanaan alternatif (JRuby, TruffleRuby) tiada GVL adalah penting untuk menulis Ruby selari yang benar-benar berprestasi.

Memandangkan concurrency ialah keperluan yang lazim dan GVL membentuk pendekatan yang betul secara asasnya, memahaminya — mengapa thread tidak menyelaraskan kerja CPU, bahawa ia membantu untuk I/O, dan bahawa proses diperlukan untuk keselarian CPU — ialah pengetahuan peringkat senior yang penting yang mencegah kesilapan yang kerap serta topik temu duga yang lazim yang mencerminkan pemahaman tentang model concurrency Ruby dan kekangan GVLnya.