0Pricing
Ruby Academy · Lektion

Threads

Nebenläufige Ausführung

Threads ist eine kostenlose Ruby Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Ruby Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Ruby Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Thread?

Ein Thread ist ein unabhängiger Ausführungspfad innerhalb Ihres Programms. Ruby ermöglicht es Ihnen, mehrere Threads auszuführen, sodass sich Arbeitsabläufe zeitlich überschneiden können.

  • Das Hauptprogramm läuft im Haupt-Thread.
  • Mit Thread.new erstellen Sie weitere Threads.
  • Threads verwenden denselben Speicher und können daher dieselben Variablen lesen und schreiben.

Threads eignen sich besonders, wenn Ihr Programm Zeit mit Warten verbringt (Netzwerk, Festplatte, sleep), da ein Thread warten kann, während ein anderer weiterarbeitet.

Einen Thread erstellen

Übergeben Sie einen Block an Thread.new. Der Block wird in einem neuen Thread ausgeführt. Rufen Sie join auf, um auf dessen Abschluss zu warten, bevor das Programm beendet wird.

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

t.join
puts "Main thread done"

Warum join wichtig ist

Wenn der Haupt-Thread endet, beendet Ruby das Programm und wartet möglicherweise nicht auf andere Threads. join blockiert den aufrufenden Thread, bis der Ziel-Thread abgeschlossen ist.

Ohne join bekommt der Worker möglicherweise keine Gelegenheit mehr, etwas auszugeben, bevor das Programm beendet wird.

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

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

Viele Threads gleichzeitig

Sie können eine Gruppe von Threads starten, sie in einem Array sammeln und anschließend für jeden Thread join aufrufen. Dies ist ein gängiges Muster für annähernd parallele I/O-Arbeiten.

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

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

Variablen gemeinsam nutzen

Threads teilen sich den Speicher. Eine vor dem Thread definierte Variable ist innerhalb des Threads sichtbar. Das ist leistungsfähig, aber auch gefährlich, wenn zwei Threads denselben Wert schreiben.

counter = 0

t = Thread.new do
  counter += 1
end

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

Race Conditions

Eine Race Condition tritt auf, wenn Threads Aktualisierungen gemeinsamer Daten verschachtelt ausführen und das Ergebnis vom zeitlichen Ablauf abhängt.

  • counter += 1 besteht tatsächlich aus Lesen, Addieren und Schreiben.
  • Zwei Threads können denselben alten Wert lesen und beide denselben neuen Wert schreiben, wodurch eine Erhöhung verloren geht.

Die Lösung besteht darin, den Zugriff mit einer Sperre zu koordinieren.

Mutex: eine Sperre

Ein Mutex (gegenseitiger Ausschluss) stellt sicher, dass jeweils nur ein Thread den geschützten Code ausführt. Umschließen Sie den kritischen Abschnitt mit 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

Einen Wert zurückgeben

Thread#value wartet, bis der Thread abgeschlossen ist, und gibt den Wert seines Blocks zurück – ähnlich wie ein automatisches join mit zusätzlichem Ergebnis.

t = Thread.new do
  2 + 3
end

puts "Result is " + t.value.to_s

Thread-lokale Variablen

Jeder Thread kann mit Thread.current[:key] eigene, über ein Symbol adressierte Werte speichern. Diese Werte sind für den jeweiligen Thread privat und werden niemals gemeinsam genutzt.

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

t.join

Ausnahmen behandeln

Wenn ein Thread einen Fehler auslöst, bleibt dieser zunächst unbemerkt, bis Sie join oder value aufrufen, wodurch der Fehler erneut ausgelöst wird. Wenn Sie Thread.abort_on_exception = true setzen, führen Fehler sofort zum Absturz des gesamten Programms, was beim Debuggen hilfreich ist.

t = Thread.new do
  raise "boom"
end

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

Wann Threads helfen

Threads spielen ihre Stärken bei I/O-gebundenen Arbeiten aus, bei denen Zeit mit Warten verbracht wird. Bei CPU-gebundenen Arbeiten helfen sie aufgrund der GVL (die als Nächstes behandelt wird) weniger.

  • Gut geeignet: viele URLs herunterladen, viele Dateien lesen.
  • Eingeschränkt: umfangreiche numerische Berechnungen über mehrere Kerne hinweg.

Schützen Sie gemeinsam genutzten veränderlichen Zustand immer mit einem Mutex.

Kurze Überprüfung

Testen Sie Ihr Verständnis von Threads.

Zusammenfassung: Threads

Sie haben die Grundlagen der Ruby-Threads gelernt:

  • Thread.new startet die nebenläufige Ausführung.
  • join wartet; value wartet und gibt ein Ergebnis zurück.
  • Threads teilen sich den Speicher, wodurch Race Conditions entstehen können.
  • Ein Mutex mit synchronize schützt den gemeinsam genutzten Zustand.
  • Threads eignen sich besonders für I/O-gebundene Arbeiten.

Als Nächstes untersuchen wir, warum Threads nicht alle CPU-Kerne vollständig nutzen können: die GVL.

Häufig gestellte Fragen

Ist die Lektion „Threads“ kostenlos?

Ja — der vollständige Text von „Threads“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Ruby Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Ruby Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Threads“?

Nebenläufige Ausführung Du übst Ruby Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Ruby Academy zu starten?

Keine Vorkenntnisse erforderlich. Ruby Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Threads“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Ruby Academy-Lektion Code schreiben und ausführen?

Ja. Jede Ruby Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Threads
  2. Die GVL erklärt
  3. Fibers
  4. Ractors
← Zurück zu Ruby Academy