Ruby Academy · Les

Threads

Gelijktijdige uitvoering

Les 1 van 413 stappen

Threads is een gratis Ruby Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Ruby Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Ruby Academy bevat in totaal 4 lessen.

Wat is een thread?

Een thread is een onafhankelijk uitvoeringspad binnen je programma. Met Ruby kun je meerdere threads uitvoeren, zodat werk elkaar in de tijd kan overlappen.

Het hoofdprogramma draait in de hoofdthread.
Je maakt meer threads met Thread.new.
Threads delen hetzelfde geheugen, zodat ze dezelfde variabelen kunnen lezen en schrijven.

Threads zijn ideaal wanneer je programma tijd besteedt aan wachten (netwerk, schijf, slapen), omdat de ene thread kan wachten terwijl een andere blijft werken.

Een thread maken

Geef een blok door aan Thread.new. Het blok wordt in een nieuwe thread uitgevoerd. Roep join aan om te wachten tot de thread klaar is voordat het programma wordt afgesloten.

t = Thread.new do
  puts "Hello from the new thread"
end

t.join
puts "Main thread done"

Waarom join belangrijk is

Wanneer de hoofdthread eindigt, sluit Ruby af en wacht het mogelijk niet op andere threads. join blokkeert de aanroeper totdat de doelthread klaar is.

Zonder join krijgt de werkthread mogelijk nooit de kans om iets af te drukken voordat het programma afsluit.

t = Thread.new do
  sleep 0.1
  puts "Worker finished"
end

puts "Waiting..."
t.join
puts "All done"

Meerdere threads tegelijk

Je kunt een groep threads starten, ze verzamelen in een array en daarna op elke thread join aanroepen. Dit is een veelgebruikt patroon voor ongeveer parallelle I/O-taken.

threads = (1..3).map do |n|
  Thread.new do
    puts "Thread number " + n.to_s
  end
end

threads.each(&:join)
puts "Finished all threads"

Variabelen delen

Threads delen geheugen. Een variabele die vóór de thread is gedefinieerd, is daarin zichtbaar. Dit is krachtig, maar ook gevaarlijk als twee threads dezelfde waarde schrijven.

counter = 0

t = Thread.new do
  counter += 1
end

t.join
puts "Counter is " + counter.to_s

Racecondities

Een raceconditie treedt op wanneer threads updates aan gedeelde gegevens door elkaar heen uitvoeren en het resultaat afhangt van het tijdstip.

counter += 1 bestaat in werkelijkheid uit lezen, optellen en schrijven.
Twee threads kunnen dezelfde oude waarde lezen en allebei dezelfde nieuwe waarde schrijven, waardoor een ophoging verloren gaat.

De oplossing is de toegang te coördineren met een vergrendeling.

Mutex: een vergrendeling

Een Mutex (wederzijdse uitsluiting) zorgt ervoor dat slechts één thread tegelijk de beveiligde code uitvoert. Omring de kritieke sectie met mutex.synchronize.

mutex = Mutex.new
counter = 0

threads = (1..5).map do
  Thread.new do
    mutex.synchronize do
      counter += 1
    end
  end
end

threads.each(&:join)
puts "Counter is " + counter.to_s

Een waarde retourneren

Thread#value wacht tot de thread klaar is en geeft de waarde van het blok terug, als een automatische join plus een resultaat.

t = Thread.new do
  2 + 3
end

puts "Result is " + t.value.to_s

Thread-lokale variabelen

Elke thread kan eigen waarden opslaan met een symbool als sleutel via Thread.current[:key]. Deze waarden zijn privé voor die thread en worden nooit gedeeld.

t = Thread.new do
  Thread.current[:name] = "worker"
  puts "Inside: " + Thread.current[:name]
end

t.join

Uitzonderingen afhandelen

Als een thread een fout opwerpt, wordt die stilgehouden totdat je join of value aanroept; die methode werpt de fout dan opnieuw op. Met Thread.abort_on_exception = true laat je fouten het hele programma onmiddellijk laten crashen, wat helpt bij het opsporen van fouten.

t = Thread.new do
  raise "boom"
end

begin
  t.join
rescue => e
  puts "Caught: " + e.message
end

Wanneer threads helpen

Threads zijn uitstekend voor I/O-gebonden werk, waarbij tijd wordt besteed aan wachten. Ze helpen minder bij CPU-gebonden werk vanwege de GVL, die hierna wordt behandeld.

Goed: veel URL's downloaden en veel bestanden lezen.
Beperkt: zware getalbewerkingen over meerdere processorkernen.

Bescherm gedeelde veranderlijke toestand altijd met een Mutex.

Kennischeck

Toets je begrip van threads.

Beantwoord dit in de interactieve les

Samenvatting: threads

Je hebt de basis van Ruby-threads geleerd:

Thread.new start gelijktijdige uitvoering.
join wacht; value wacht en geeft een resultaat terug.
Threads delen geheugen, wat racecondities veroorzaakt.
Een Mutex met synchronize beschermt gedeelde toestand.
Threads zijn uitstekend voor I/O-gebonden werk.

Vervolgens onderzoeken we waarom threads niet alle CPU-kernen volledig kunnen benutten: de GVL.

Gratis beginnen

Leer Ruby met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 29
Lessen: 109

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Threads” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Ruby Academy, waaronder “Threads”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Ruby Academy bevat in totaal 4 lessen.

Wat leer ik in “Threads”?

Gelijktijdige uitvoering Je oefent met Ruby Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Ruby Academy te beginnen?

Ervaring vooraf is niet nodig. Ruby Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Threads”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Ruby Academy?

Ja. Elke les over Ruby Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Ruby Academy