Design af aktørsystemer
Lær at designe og implementere aktørhierarkier, definere aktøradfærd samt sende og modtage meddelelser.
Design af aktørsystemer er en gratis Scala til backendudvikling og funktionel programmering-lektion på CoddyKit. Dette er lektion 2 af 3. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Scala til backendudvikling og funktionel programmering, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Scala til backendudvikling og funktionel programmering-kurset indeholder 3 lektioner i alt.
Introduktion til design af aktørsystemer
Velkommen til lektion 2! I den forrige lektion lærte vi det grundlæggende i Akkas aktørmodel. Nu dykker vi ned i design af Akka-aktørsystemer.
Et veldesignet aktørsystem er robust, skalerbart og nemt at vedligeholde. Vi undersøger, hvordan du strukturerer dine aktører, definerer deres adfærd og gør dem i stand til at kommunikere effektivt.
Forståelse af aktørhierarkier
Akka-aktører er organiseret i et trælignende hierarki, ligesom et filsystem. Alle aktører bortset fra aktøren 'root' har en forælder.
- Forælder-barn-forhold: En aktør, der opretter en anden aktør, bliver dens forælder.
- Supervision: Dette hierarki er afgørende for Akkas fejltolerance. Forældre er ansvarlige for at supervisere deres børn (mere om dette i næste lektion!).
- Stiadressering: Hver aktør har en unik sti, der afspejler dens placering i hierarkiet, f.eks.
/user/parentActor/childActor.
Opsætning af dit ActorSystem
ActorSystem er indgangspunktet for alle Akka-applikationer. Det administrerer de ressourcer, som aktører har brug for, herunder trådpuljer og planlæggere.
Du opretter det én gang pr. applikation og bruger det derefter til at oprette dine aktører på øverste niveau. Det fungerer som beholderen for hele din aktørapplikation.
Prøv at køre denne enkle kode for at oprette et ActorSystem:
import akka.actor.ActorSystem
object AkkaSystemApp {
def main(args: Array[String]): Unit = {
// Create an ActorSystem with a unique name
val system = ActorSystem("MyFirstActorSystem")
println("ActorSystem created: " + system.name)
// Remember to terminate the system when done!
system.terminate()
}
}Definition af aktøradfærd
En aktørs adfærd bestemmer, hvordan den reagerer på forskellige beskeder. I Scala definerer du dette ved at udvide Actor-traitet og implementere receive-metoden.
receive-metoden er en partiel funktion, der matcher indgående beskeder med bestemte handlinger.- Hver aktør behandler beskeder én ad gangen i rækkefølge, hvilket sikrer trådsikkerhed for dens interne tilstand.
ActorRef: Aktørens adresse
Du interagerer ikke direkte med aktørinstanser. I stedet sender du beskeder til en ActorRef. Tænk på ActorRef som en postadresse til en aktør.
- Det er et håndtag, der repræsenterer en bestemt aktør i systemet.
- Beskeder, der sendes til en
ActorRef, placeres i aktørens postkasse. - Du får en
ActorRef, når du opretter en aktør ved hjælp afactorOf.
Afsendelse af beskeder til aktører
Den primære måde, aktører kommunikerer på, er ved at sende beskeder. Den mest almindelige måde at sende en besked på er at bruge !-metoden (udtales 'tell').
receiverActorRef ! "Your message here"
tell-metoden er asynkron og følger princippet send og glem. Den sender beskeden uden at vente på et svar.
Lad os kombinere oprettelse af en aktør med at sende beskeder til den:
import akka.actor.{Actor, ActorRef, Props, ActorSystem}
// 1. Define the actor's behavior
class GreeterActor extends Actor {
def receive = {
case "hello" => println(s"Greeter: Hello from ${self.path.name}!")
case msg: String => println(s"Greeter: Received message: '$msg'")
case _ => println("Greeter: Received something unexpected!")
}
}
object SimpleActorApp {
def main(args: Array[String]): Unit = {
// 2. Create the ActorSystem
val system = ActorSystem("GreeterSystem")
// 3. Create a top-level actor and get its ActorRef
val greeter: ActorRef = system.actorOf(Props[GreeterActor], "myGreeter")
// 4. Send messages to the actor using '!'
greeter ! "hello"
greeter ! "How are you doing today?"
greeter ! 123 // This will match the _ case
// Give actors time to process messages, then terminate
Thread.sleep(1000)
system.terminate()
}
}Oprettelse af underordnede aktører
Aktører kan oprette andre aktører og dermed danne det hierarki, vi har gennemgået. En forælderaktør opretter sine underordnede aktører ved hjælp af context.actorOf.
context.actorOf: Bruges af en aktør til at oprette sine børn.system.actorOf: Bruges af applikationen til at oprette aktører på øverste niveau (guardian-aktører).
Oprettelse af underordnede aktører hjælper med at organisere dit system, uddelegere opgaver og isolere fejl.
Kommunikation mellem forælder og barn
Aktører kommunikerer ved at sende beskeder til hinandens ActorRef. En underordnet aktør kan få sin forælderaktørs ActorRef via context.parent. En aktør kan bruge sender() til at svare afsenderen af en besked.
Lad os se et eksempel, hvor en forælder opretter et barn, beder det udføre arbejde, og barnet melder tilbage, når det er færdigt:
import akka.actor.{Actor, ActorRef, Props, ActorSystem}
import scala.concurrent.ExecutionContext.Implicits.global
// Child Actor Definition: Does work and replies to sender
class ChildActor extends Actor {
def receive = {
case "work" =>
println(s"ChildActor (${self.path.name}): Doing work from ${sender().path.name}")
sender() ! "done" // Reply 'done' to the sender (parent)
}
}
// Parent Actor Definition: Creates child, sends work, receives reply
class ParentActor extends Actor {
// Create a child actor when the parent starts
val child: ActorRef = context.actorOf(Props[ChildActor], "myChild")
def receive = {
case "start" =>
println("ParentActor: Kicking off child's work.")
child ! "work" // Tell the child to do 'work'
case "done" =>
println(s"ParentActor: Child ${sender().path.name} reported 'done'.")
context.stop(child) // Stop the child actor
context.stop(self) // Stop the parent actor
}
}
object HierarchyApp {
def main(args: Array[String]): Unit = {
val system = ActorSystem("HierarchySystem")
val parent: ActorRef = system.actorOf(Props[ParentActor], "parentActor")
parent ! "start" // Start the interaction
// Wait for the system to terminate (actors will stop themselves)
system.whenTerminated.onComplete(_ => println("ActorSystem terminated."))
}
}Sikker standsning af aktører
Aktører bør stoppes på en kontrolleret måde, når der ikke længere er brug for dem, så ressourcer frigives. Du kan stoppe en aktør på flere måder:
context.stop(self): En aktør stopper sig selv.context.stop(childRef): En forælder stopper et af sine børn.system.stop(actorRef): Bruges til aktører på øverste niveau, men normalt stopper du hele systemet.
Når en aktør stopper, behandler den alle beskeder i sin postkasse, før den afsluttes. Dens børn stoppes også rekursivt.
Hurtig test: aktørdesign
Se på følgende kodestykke med en Akka-aktør. Hvad er den korrekte måde for MyChildActor at sende en besked tilbage til den forælder, der oprettede den, MyParentActor, hvis MyParentActor var afsenderen af den oprindelige 'request'-besked?
Opsummering: Design af aktørsystemer
Godt gået! I denne lektion har vi gennemgået vigtige aspekter af design af Akka-aktørsystemer:
- Aktører er organiseret i hierarkier, som er afgørende for supervision og struktur.
ActorSystemer din applikations indgangspunkt til Akka.- Du definerer aktørers adfærd ved hjælp af
receive-metoden. ActorRefer adressen, som bruges til at sende beskeder.- Aktører kommunikerer asynkront ved hjælp af
!(tell)-metoden. - Forældre opretter børn med
context.actorOf, og børn kan svare ved hjælp afsender(). - Aktører kan stoppes på en kontrolleret måde ved hjælp af
context.stop().
Dernæst går vi i dybden med Akkas effektive supervisionsstrategier og med, hvordan fejl håndteres på en kontrolleret måde!
Lær Scala med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 39
- Lektioner
- 143
Ofte stillede spørgsmål
Er lektionen “Design af aktørsystemer” gratis?
Ja — hele teksten til “Design af aktørsystemer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Scala til backendudvikling og funktionel programmering-kurset, skal du opgradere til CoddyKit PRO. Scala til backendudvikling og funktionel programmering-kurset indeholder 3 lektioner i alt.
Hvad lærer jeg i “Design af aktørsystemer”?
Lær at designe og implementere aktørhierarkier, definere aktøradfærd samt sende og modtage meddelelser. Du øver dig i Scala til backendudvikling og funktionel programmering med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Scala til backendudvikling og funktionel programmering?
Der kræves ingen tidligere erfaring. Scala til backendudvikling og funktionel programmering på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 3.
Hvor lang tid tager lektionen “Design af aktørsystemer”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Scala til backendudvikling og funktionel programmering-lektion?
Ja. Alle Scala til backendudvikling og funktionel programmering-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Grundprincipper i Akka Actor Model
- Design af aktørsystemer
- Supervision og fejltolerance