Hoe wordt preemptieve multitasking geïmplementeerd in Ruby?

In "zuivere" Ruby (MRI, JRuby, TruffleRuby) bestaat er geen echte preemptieve multitasking voor gelijktijdige uitvoering van code in één proces vanwege de Global Interpreter Lock (GIL). De GIL staat toe dat slechts één thread op een gegeven moment Ruby-code uitvoert.

Echter, preemptieve multitasking in Ruby bestaat op het niveau van input/output. Wanneer een thread een blokkerende input/output-operatie uitvoert (bijvoorbeeld een bestand lezen, een netwerkverzoek), wordt de GIL vrijgegeven, waardoor een andere thread Ruby-code kan uitvoeren. Dit maakt parallelisme mogelijk voor input/output-operaties, maar niet voor CPU-bound taken.

Er zijn alternatieve Ruby-implementaties (bijvoorbeeld Rubinius) die geprobeerd hebben om echte multitasking zonder GIL te implementeren, maar deze zijn niet zo wijdverspreid als MRI.

Voor parallelle uitvoering van CPU-bound taken in Ruby worden meestal:

• Processen (fork): Elk proces heeft zijn eigen GIL, wat parallel uitvoeren van Ruby-code mogelijk maakt. Gegevensuitwisseling tussen processen vereist expliciete mechanismen (IPC).
• Externe bibliotheken en C-extensies: Operaties geïmplementeerd in C kunnen buiten controle van de GIL worden uitgevoerd, wat parallelisme mogelijk maakt.

In Ruby 3.0 is de Fibers Scheduler geïntroduceerd, die asynchroon uitvoeren van input/output-operaties mogelijk maakt met behulp van fibers en niet-blokkerende oproepen. Dit verbetert de prestaties voor I/O-bound taken, maar maakt CPU-bound taken niet echt parallel in één proces.

# Voorbeeld van het gebruik van threads in MRI voor I/O-bound taken
require 'net/http'
require 'uri'

urls = %w[http://example.com http://ruby-lang.org]
threads = urls.map do |url|
  Thread.new do
    uri = URI.parse(url)
    response = Net::HTTP.get_response(uri)
    puts "Gedownload #{url} (Status: #{response.code})"
  end
end

threads.each(&:join)

Dus, hoewel Ruby mechanismen heeft om met threads te werken, wordt echte preemptieve multitasking voor CPU-gerelateerde taken meestal bereikt door gebruik te maken van meerdere processen of specifieke Ruby-implementaties zonder GIL.