Ruby Academy · Lekcja

Ractors

Prawdziwa równoległość

Ractors to bezpłatna lekcja Ruby Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Ruby Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Ruby Academy zawiera 4 lekcji w sumie.

Czym jest Ractor?

Ractor (Ruby Actor) to mechanizm współbieżności wprowadzony w Ruby 3, który zapewnia prawdziwą równoległość. Każdy Ractor wykonuje kod Ruby niezależnie, więc dwa Ractory mogą w tym samym czasie korzystać z dwóch rdzeni CPU.

Ractory nie współdzielą modyfikowalnych obiektów, dzięki czemu omijają ograniczenie GVL.
Komunikują się za pomocą wiadomości.

Ractory są nadal eksperymentalne, dlatego Ruby wyświetla ostrzeżenie podczas ich używania.

Tworzenie Ractora

Utwórz go za pomocą Ractor.new i bloku. Blok jest wykonywany równolegle. Użyj take, aby pobrać końcową wartość bloku.

r = Ractor.new do
  2 + 3
end

puts r.take

Brak współdzielonego stanu

Najważniejsza zasada jest następująca: Ractory nie mogą swobodnie współdzielić modyfikowalnych obiektów. Blok Ractora nie przechwytuje zewnętrznych zmiennych lokalnych tak jak zwykły blok. Dane trzeba przekazać jawnie.

Ta izolacja sprawia, że wykonywanie równoległe jest bezpieczne bez używania blokad.

Przekazywanie argumentów do środka

Argumenty przekazane do Ractor.new są dostarczane do parametrów bloku. To bezpieczny sposób przekazywania danych do Ractora.

r = Ractor.new(10) do |x|
  x * x
end

puts r.take

Wysyłanie wiadomości

Ractory mają skrzynkę odbiorczą na wiadomości. Wiadomości wysyła się za pomocą ractor.send(value), a odbiera wewnątrz bloku za pomocą Ractor.receive.

r = Ractor.new do
  msg = Ractor.receive
  "got: " + msg
end

r.send("hello")
puts r.take

Wypychanie a pobieranie

Dwa kierunki komunikacji:

Wypychanie: wysyłanie za pomocą send do Ractora i odczytywanie za pomocą Ractor.receive.
Pobieranie: Ractor emituje wartość za pomocą Ractor.yield, a kod zewnętrzny odczytuje ją za pomocą take.

Dzięki temu Ractory mogą razem tworzyć potoki przetwarzania.

r = Ractor.new do
  Ractor.yield 1
  Ractor.yield 2
end

puts r.take
puts r.take

Zamrożone i współdzielone obiekty

Niektóre obiekty można współdzielić między Ractorami, ponieważ nie można ich modyfikować: true, false, nil, liczby, symbole i głęboko zamrożone obiekty.

Ractor.make_shareable zamraża graf obiektów, dzięki czemu można go bezpiecznie współdzielić.

data = Ractor.make_shareable([1, 2, 3])
puts "Frozen? " + data.frozen?.to_s

Kopiowanie a przenoszenie

Podczas wysyłania obiektu, którego nie można współdzielić, Ractor domyślnie wykonuje jego głęboką kopię, dzięki czemu każda ze stron ma własną kopię. Można zamiast tego przenieść obiekt za pomocą send(obj, move: true), co przekazuje własność i sprawia, że oryginału nie można już używać.

Przenoszenie eliminuje koszt kopiowania dużych obiektów.

Praca równoległa

Podziel kosztowne obliczeniowo zadania między Ractory i zbierz wyniki. Ponieważ każdy Ractor działa niezależnie, można w ten sposób wykorzystać wiele rdzeni.

ractors = (1..3).map do |n|
  Ractor.new(n) do |x|
    x * 100
  end
end

results = ractors.map(&:take)
puts "Results: " + results.join(", ")

Ractory a wątki

Porównanie:

Wątki współdzielą pamięć i wymagają blokad; Ractory są izolowane i wymagają komunikatów.
Wątki nie wykonują równolegle obliczeń Ruby obciążających procesor; Ractory to potrafią.
Ractory mają bardziej rygorystyczne zasady, co zapobiega wielu błędom współbieżności.

Ceną są bardziej sztywne zasady współdzielenia danych.

Kiedy używać Ractorów

Wybierz Ractory, gdy:

Masz zadania ograniczone wydajnością procesora i chcesz wykorzystać wiele rdzeni w jednym procesie.
Chcesz użyć izolacji, aby uniknąć błędów związanych ze współdzielonym stanem.

Pamiętaj, że Ractory są eksperymentalne: interfejsy API mogą się zmieniać, a wiele gemów nie jest jeszcze bezpiecznych dla Ractorów.

Szybkie sprawdzenie

Proszę sprawdzić swoją wiedzę o Ractorach.

Podsumowanie: Ractory

W tej części poznano równoległość wewnątrz procesu z użyciem Ractorów:

Ractor.new uruchamia kod równolegle, a take pobiera jego wynik.
Dane można przekazywać za pomocą argumentów lub send, a odbierać za pomocą Ractor.receive.
Obiekty są kopiowane lub przenoszone, a nie dowolnie współdzielone.
Ractor.make_shareable zamraża dane, aby można je było bezpiecznie współdzielić.

To kończy kurs Współbieżność w Ruby: wątki, GVL, włókna i Ractory.

Często zadawane pytania

Czy lekcja „Ractors” jest bezpłatna?

Tak — pełny tekst „Ractors” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Ruby Academy, przejdź na CoddyKit PRO. Kurs Ruby Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Ractors”?

Prawdziwa równoległość Ćwiczysz Ruby Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Ruby Academy?

Nie wymagamy żadnego doświadczenia. Ruby Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Ractors”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Ruby Academy?

Tak. Każda lekcja Ruby Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Ruby Academy