0Pricing
Scala for Backend Engineering & Functional Programming · บทเรียน

การออกแบบระบบแอกเตอร์

เรียนรู้การออกแบบและสร้างลำดับชั้นของแอกเตอร์ กำหนดพฤติกรรมของแอกเตอร์ และส่งหรือรับข้อความ

การออกแบบระบบแอกเตอร์ เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน

การสร้างระบบแอกเตอร์: บทนำ

ยินดีต้อนรับสู่บทเรียนที่ 2! ในบทเรียนก่อนหน้านี้ เราได้เรียนรู้พื้นฐานของแบบจำลองแอกเตอร์ของ Akka แล้ว ตอนนี้มาดู การออกแบบระบบแอกเตอร์ของ Akka กัน

ระบบแอกเตอร์ที่ออกแบบมาอย่างดีจะแข็งแกร่ง ปรับขนาดได้ และดูแลรักษาได้ง่าย เราจะสำรวจวิธีจัดโครงสร้างแอกเตอร์ กำหนดพฤติกรรมของแอกเตอร์ และทำให้แอกเตอร์สื่อสารกันได้อย่างมีประสิทธิภาพ

ทำความเข้าใจลำดับชั้นของแอกเตอร์

แอกเตอร์ของ Akka ถูกจัดระเบียบเป็น ลำดับชั้นลักษณะคล้ายต้นไม้ เช่นเดียวกับระบบไฟล์ แอกเตอร์ทุกตัว ยกเว้นแอกเตอร์ 'ราก' จะมีแอกเตอร์แม่

  • ความสัมพันธ์แม่-ลูก: แอกเตอร์ที่สร้างแอกเตอร์อีกตัวจะกลายเป็นแอกเตอร์แม่ของแอกเตอร์นั้น
  • การกำกับดูแล: ลำดับชั้นนี้มีความสำคัญต่อการทนต่อข้อผิดพลาดของ Akka แอกเตอร์แม่มีหน้าที่กำกับดูแลแอกเตอร์ลูก (เราจะกล่าวถึงเรื่องนี้เพิ่มเติมในบทเรียนถัดไป)
  • การระบุที่อยู่ตามเส้นทาง: แอกเตอร์แต่ละตัวมีเส้นทางเฉพาะที่สะท้อนตำแหน่งในลำดับชั้น เช่น /user/parentActor/childActor

การตั้งค่า ActorSystem

ActorSystem เป็นจุดเริ่มต้นของแอปพลิเคชัน Akka ทั้งหมด โดยจัดการทรัพยากรที่จำเป็นสำหรับแอกเตอร์ ซึ่งรวมถึงกลุ่มเธรดและตัวจัดตารางเวลา

คุณสร้างระบบนี้เพียงครั้งเดียวต่อแอปพลิเคชัน แล้วใช้ระบบนี้สร้างแอกเตอร์ระดับบนสุด ระบบนี้เปรียบเสมือนภาชนะที่บรรจุแอปพลิเคชันแอกเตอร์ทั้งหมดของคุณ

ลองเรียกใช้โค้ดอย่างง่ายต่อไปนี้เพื่อสร้าง 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()
  }
}

การกำหนดพฤติกรรมของแอกเตอร์

พฤติกรรมของแอกเตอร์จะกำหนดว่าแอกเตอร์ตอบสนองต่อข้อความต่าง ๆ อย่างไร ใน Scala คุณกำหนดพฤติกรรมนี้โดยสืบทอดคุณลักษณะ Actor และใช้งานเมธอด receive

  • เมธอด receive เป็น ฟังก์ชันบางส่วนที่จับคู่ข้อความขาเข้ากับการดำเนินการเฉพาะ
  • แอกเตอร์แต่ละตัวประมวลผลข้อความทีละข้อความตามลำดับ ทำให้มั่นใจได้ถึงความปลอดภัยของเธรดสำหรับสถานะภายใน

ActorRef: ที่อยู่ของแอกเตอร์

คุณไม่ได้โต้ตอบกับอินสแตนซ์ของแอกเตอร์โดยตรง แต่จะส่งข้อความไปยัง ActorRef แทน ให้คิดว่า ActorRef เป็นที่อยู่ไปรษณีย์ของแอกเตอร์

  • เป็นตัวอ้างอิงที่แทนแอกเตอร์เฉพาะตัวหนึ่งภายในระบบ
  • ข้อความที่ส่งไปยัง ActorRef จะถูกนำไปไว้ในกล่องจดหมายของแอกเตอร์
  • คุณจะได้รับ ActorRef เมื่อสร้างแอกเตอร์โดยใช้ actorOf

การส่งข้อความไปยังแอกเตอร์

วิธีหลักที่แอกเตอร์ใช้สื่อสารกันคือการส่งข้อความ วิธีส่งข้อความที่ใช้บ่อยที่สุดคือการใช้เมธอด ! (อ่านว่า 'tell')

receiverActorRef ! "Your message here"

เมธอด tell ทำงานแบบอะซิงโครนัสและเป็นแบบส่งแล้วไม่ต้องรอผล เมธอดนี้จะส่งข้อความและไม่รอการตอบกลับ

มารวมการสร้างแอกเตอร์กับการส่งข้อความไปยังแอกเตอร์กัน:

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()
  }
}

การสร้างแอกเตอร์ลูก

แอกเตอร์สามารถสร้างแอกเตอร์อื่น ๆ ได้ ทำให้เกิดลำดับชั้นตามที่เราได้กล่าวถึง แอกเตอร์แม่จะสร้างแอกเตอร์ลูกโดยใช้ context.actorOf

  • context.actorOf: ใช้โดยแอกเตอร์เพื่อสร้างแอกเตอร์ลูก
  • system.actorOf: ใช้โดยแอปพลิเคชันเพื่อสร้างแอกเตอร์ระดับบนสุด (แอกเตอร์ผู้พิทักษ์)

การสร้างแอกเตอร์ลูกช่วยจัดระเบียบระบบ มอบหมายงาน และแยกความล้มเหลวออกจากกัน

การสื่อสารระหว่างแม่กับลูก

แอกเตอร์สื่อสารกันโดยส่งข้อความไปยัง ActorRef ของกันและกัน แอกเตอร์ลูกสามารถรับ ActorRef ของแอกเตอร์แม่ผ่าน context.parent หากต้องการตอบกลับผู้ส่งข้อความ แอกเตอร์สามารถใช้ sender()

มาดูตัวอย่างที่แอกเตอร์แม่สร้างแอกเตอร์ลูก สั่งให้ทำงาน และให้แอกเตอร์ลูกรายงานกลับเมื่อทำงานเสร็จกัน:

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."))
  }
}

การหยุดแอกเตอร์อย่างเหมาะสม

ควรหยุดแอกเตอร์อย่างเหมาะสมเมื่อไม่จำเป็นต้องใช้งานแล้ว เพื่อคืนทรัพยากร คุณสามารถหยุดแอกเตอร์ได้หลายวิธี:

  • context.stop(self): แอกเตอร์หยุดตัวเอง
  • context.stop(childRef): แอกเตอร์แม่หยุดแอกเตอร์ลูกตัวใดตัวหนึ่ง
  • system.stop(actorRef): ใช้กับแอกเตอร์ระดับบนสุด แต่โดยทั่วไปจะหยุดทั้งระบบ

เมื่อแอกเตอร์หยุดทำงาน แอกเตอร์จะประมวลผลข้อความทั้งหมดในกล่องจดหมายก่อนยุติการทำงาน แอกเตอร์ลูกของมันจะถูกหยุดแบบเรียกซ้ำด้วย

ตรวจสอบสั้น ๆ: การออกแบบแอกเตอร์

พิจารณาส่วนย่อยของโค้ดแอกเตอร์ Akka ต่อไปนี้ วิธีที่ถูกต้องสำหรับ MyChildActor ในการส่งข้อความกลับไปยังแอกเตอร์แม่ที่สร้างมันขึ้นมาอย่าง MyParentActor คืออะไร หาก MyParentActor เป็นผู้ส่งข้อความ 'request' เริ่มต้น

ทบทวน: การออกแบบระบบแอกเตอร์

ทำได้ดีมาก! ในบทเรียนนี้ เราได้ครอบคลุมประเด็นสำคัญของการออกแบบระบบแอกเตอร์ของ Akka:

  • แอกเตอร์ถูกจัดระเบียบเป็นลำดับชั้น ซึ่งมีความสำคัญต่อการกำกับดูแลและโครงสร้าง
  • ActorSystem เป็นจุดเริ่มต้นของแอปพลิเคชันสำหรับ Akka
  • คุณกำหนดพฤติกรรมของแอกเตอร์โดยใช้เมธอด receive
  • ActorRef คือที่อยู่สำหรับส่งข้อความ
  • แอกเตอร์สื่อสารกันแบบอะซิงโครนัสโดยใช้เมธอด ! (tell)
  • แอกเตอร์แม่สร้างแอกเตอร์ลูกด้วย context.actorOf และแอกเตอร์ลูกสามารถตอบกลับโดยใช้ sender()
  • สามารถหยุดแอกเตอร์อย่างเหมาะสมได้โดยใช้ context.stop()

ถัดไป เราจะเจาะลึกกลยุทธ์การกำกับดูแลอันทรงพลังของ Akka และวิธีจัดการความล้มเหลวอย่างเหมาะสม

คำถามที่พบบ่อย

บทเรียน “การออกแบบระบบแอกเตอร์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การออกแบบระบบแอกเตอร์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การออกแบบระบบแอกเตอร์”

เรียนรู้การออกแบบและสร้างลำดับชั้นของแอกเตอร์ กำหนดพฤติกรรมของแอกเตอร์ และส่งหรือรับข้อความ คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน

บทเรียน “การออกแบบระบบแอกเตอร์” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. พื้นฐานโมเดลแอกเตอร์ของ Akka
  2. การออกแบบระบบแอกเตอร์
  3. การควบคุมดูแลและความทนทานต่อความผิดพลาด
← กลับไปที่ Scala for Backend Engineering & Functional Programming