Scala for Backend Engineering & Functional Programming · Lekcja

Podstawy modelu aktorów Akka

Poznaj zasady modelu aktorów, cykl życia aktora i przekazywanie komunikatów na potrzeby współbieżnego wykonywania.

Lekcja 1 z 312 kroki

Podstawy modelu aktorów Akka to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 1 z 3. 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 Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Wyzwania związane ze współbieżnością

We współczesnych aplikacjach zadania często muszą być wykonywane jednocześnie. Nazywamy to współbieżnością. Choć współbieżność jest potężnym mechanizmem, wiąże się również z wyzwaniami.

Wyścigi: Występują, gdy wiele wątków próbuje jednocześnie uzyskać dostęp do współdzielonych danych i je modyfikować, prowadząc do nieprzewidywalnych wyników.
Zakleszczenia: Występują, gdy co najmniej dwa wątki są bezterminowo zablokowane i czekają, aż drugi zwolni zasoby.

Tradycyjne modele wątków mogą być złożone i podatne na błędy podczas rozwiązywania takich problemów.

Poznawanie modelu aktorów

Model aktorów zapewnia skuteczny sposób zarządzania współbieżnością. Zamiast współdzielić pamięć, aktorzy komunikują się wyłącznie za pomocą wysyłania sobie wiadomości.

Izolacja: Każdy aktor ma własny prywatny stan, do którego żaden inny aktor nie może uzyskać bezpośredniego dostępu.
Przekazywanie wiadomości: Aktorzy komunikują się, wysyłając do swoich skrzynek niezmienne wiadomości.
Asynchroniczność: Wysyłanie wiadomości nie blokuje wykonania; nadawca nie czeka na odpowiedź.

Proszę wyobrazić sobie aktorów jako niezależne osoby, z których każda ma własne biurko (stan) i korzysta z poczty (przekazywanie wiadomości).

Dlaczego warto wybrać Akka?

Akka to zestaw narzędzi open source, który udostępnia model aktorów w Scali (i Javie). Został zaprojektowany do tworzenia wysoce współbieżnych, rozproszonych i odpornych na błędy aplikacji.

Prostota: Akka upraszcza programowanie współbieżne, ukrywając szczegóły niskopoziomowej obsługi wątków.
Skalowalność: Pozwala łatwo skalować aplikacje od pojedynczej maszyny do klastra maszyn.
Odporność: Ma wbudowane mechanizmy obsługi błędów, dzięki którym systemy mogą samodzielnie powracać do sprawności.

Akka pomaga pisać systemy, które „po prostu działają” nawet przy dużym obciążeniu lub częściowych awariach.

Wewnątrz aktora Akka

Aktor Akka to podstawowa jednostka współbieżności. Każdy aktor ma:

Zachowanie: Określone przez sposób reagowania na wiadomości.
Skrzynkę: Miejsce, w którym oczekują przychodzące wiadomości. Wiadomości są przetwarzane pojedynczo, w kolejności.
Prywatny stan: Dane należące wyłącznie do aktora, które może modyfikować tylko sam aktor.
ActorRef: Unikalny adres służący do wysyłania wiadomości do tego aktora.

Tak ścisła izolacja zapobiega typowym błędom współbieżności, takim jak wyścigi.

Państwa pierwszy ActorSystem

Zanim będą Państwo mogli utworzyć aktorów, potrzebują Państwo obiektu ActorSystem. Jest to punkt wejścia do Akka, zarządzający wszystkimi aktorami w swoim zakresie.

Udostępnia usługi takie jak planowanie, konfiguracja i hierarchia nadzoru (które omówimy później).

Proszę spróbować go utworzyć:

import akka.actor.ActorSystem

object Main extends App {
  // Create an ActorSystem
  val system = ActorSystem("MyActorSystem")
  println(s"ActorSystem created: ${system.name}")

  // Terminate the system when done (important for clean shutdown)
  system.terminate()
}

Tworzenie pierwszego aktora

Aby utworzyć aktora, należy zdefiniować klasę rozszerzającą cechę Actor Akka i zaimplementować metodę receive.

Metoda receive określa sposób przetwarzania przychodzących wiadomości przez aktora. Jest funkcją częściową, która dopasowuje typy wiadomości.

import akka.actor.Actor

class GreeterActor extends Actor {
  def receive: Receive = {
    case message: String =>
      println(s"Greeter received: $message")
  }
}

Tworzenie aktorów i ActorRef

Aktorów tworzy się (czyli „uruchamia”) za pomocą metody actorOf obiektu ActorSystem. Metoda ta zwraca obiekt ActorRef.

ActorRef to lekki, możliwy do serializacji uchwyt do aktora. Używa się go do wysyłania wiadomości do tego aktora, nigdy zaś do bezpośredniej interakcji z samą instancją aktora.

import akka.actor.{ActorSystem, Props, Actor}

class GreeterActor extends Actor {
  def receive: Receive = {
    case message: String =>
      println(s"Greeter received: $message")
  }
}

object Main extends App {
  val system = ActorSystem("MyActorSystem")

  // Create an actor and get its ActorRef
  val greeterRef = system.actorOf(Props[GreeterActor], "greeter")
  println(s"Greeter actor created with path: ${greeterRef.path}")

  system.terminate()
}

Wysyłanie wiadomości do aktorów

Komunikacja między aktorami odbywa się wyłącznie za pośrednictwem komunikatów. Komunikaty do obiektu ActorRef wysyła się za pomocą operatora ! (tell).

Komunikaty są wysyłane asynchronicznie i zazwyczaj są niezmiennymi klasami przypadków lub prostymi typami, takimi jak String.

import akka.actor.{ActorSystem, Props, Actor}

class GreeterActor extends Actor {
  def receive: Receive = {
    case message: String =>
      println(s"Greeter received: $message")
  }
}

object Main extends App {
  val system = ActorSystem("MyActorSystem")

  val greeterRef = system.actorOf(Props[GreeterActor], "greeter")

  // Send a message to the greeter actor
  greeterRef ! "Hello Akka!"
  greeterRef ! "How are you?"

  // Give actors time to process messages before terminating
  Thread.sleep(100)
  system.terminate()
}

Podstawy cyklu życia aktora

Aktorzy mają cykl życia — od utworzenia do zakończenia. Akka udostępnia punkty zaczepienia umożliwiające wykonanie czynności przygotowawczych i porządkowych:

preStart(): Wywoływana tuż przed rozpoczęciem przetwarzania pierwszego komunikatu przez aktora. Przydatna do inicjalizowania zasobów.
postStop(): Wywoływana po zatrzymaniu aktora, a przed jego całkowitym usunięciem z systemu. Przydatna do zwalniania zasobów.

Zrozumienie cyklu życia ma kluczowe znaczenie dla efektywnego zarządzania zasobami aktorów.

Hierarchie aktorów

Aktorzy są zorganizowani w hierarchię przypominającą system plików. Każdy aktor, z wyjątkiem aktora „głównego opiekuna”, ma rodzica.

Nadzorowanie: Aktorzy-rodzice odpowiadają za nadzorowanie swoich dzieci. Jeśli aktor-dziecko ulegnie awarii, jego rodzic decyduje, jak obsłużyć tę awarię, na przykład ponownie uruchomić aktora lub go zatrzymać.
Ścieżka: Każdy aktor ma unikatową ścieżkę, taką jak /user/myActor/childActor, która odzwierciedla jego położenie w hierarchii.

Ta hierarchia ma kluczowe znaczenie dla funkcji tolerowania błędów i odporności systemu Akka.

Sprawdzenie podstaw Akka

Sprawdźmy, jak dobrze rozumie Pan/Pani podstawy modelu aktorów Akka.

Odpowiedz w interaktywnej lekcji

Podsumowanie: model aktorów Akka

Świetnie! W tej lekcji poznał(a) Pan/Pani podstawowe pojęcia modelu aktorów Akka:

Problemy związane z tradycyjną współbieżnością.
Zasady modelu aktorów: izolacja, przekazywanie komunikatów i brak współdzielonego stanu.
Rola Akka jako zestawu narzędzi do budowania niezawodnych systemów aktorów.
Sposób definiowania ActorSystem i prostych aktorów w języku Scala.
Sposób uruchamiania aktorów i wysyłania do nich komunikatów za pomocą ActorRef.
Podstawy cyklu życia i hierarchii aktorów.

W następnej części przyjrzymy się bliżej projektowaniu systemów aktorów i obsłudze bardziej złożonych interakcji!

Bezpłatny start

Ucz się Scala dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 39
Lekcje: 143

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Podstawy modelu aktorów Akka” jest bezpłatna?

Tak — pełny tekst „Podstawy modelu aktorów Akka” 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 Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.

Co nauczysz się w „Podstawy modelu aktorów Akka”?

Poznaj zasady modelu aktorów, cykl życia aktora i przekazywanie komunikatów na potrzeby współbieżnego wykonywania. Ćwiczysz Scala for Backend Engineering & Functional Programming 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ąć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming 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 1 z 3.

Ile czasu zajmuje lekcja „Podstawy modelu aktorów Akka”?

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 Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming