Scala for Backend Engineering & Functional Programming · Pelajaran

Merancang Sistem Aktor

Pelajari cara merancang dan menerapkan hierarki aktor, mendefinisikan perilaku aktor, serta mengirim dan menerima pesan.

Merancang Sistem Aktor adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Pengantar Perancangan Sistem Aktor

Selamat datang di Pelajaran 2! Pada pelajaran sebelumnya, kita mempelajari dasar-dasar Model Aktor Akka. Sekarang, mari kita membahas perancangan Sistem Aktor Akka.

Sistem aktor yang dirancang dengan baik bersifat tangguh, dapat diskalakan, dan mudah dipelihara. Kita akan mempelajari cara menyusun aktor, menentukan perilakunya, dan memungkinkan mereka berkomunikasi secara efektif.

Memahami Hierarki Aktor

Aktor Akka diatur dalam hierarki seperti pohon, mirip seperti sistem berkas. Setiap aktor, kecuali aktor 'akar', memiliki induk.

Hubungan Induk-Anak: Aktor yang membuat aktor lain menjadi induknya.
Supervisi: Hierarki ini sangat penting bagi toleransi kesalahan Akka. Induk bertanggung jawab mengawasi anaknya, yang akan dibahas lebih lanjut pada pelajaran berikutnya!
Pengalamatan Berbasis Jalur: Setiap aktor memiliki jalur unik yang mencerminkan posisinya dalam hierarki, seperti /user/parentActor/childActor.

Menyiapkan ActorSystem

ActorSystem adalah titik masuk untuk semua aplikasi Akka. Komponen ini mengelola sumber daya yang dibutuhkan aktor, termasuk kumpulan utas dan penjadwal.

Anda membuatnya satu kali untuk setiap aplikasi, lalu menggunakannya untuk membuat aktor tingkat atas. Komponen ini seperti wadah untuk seluruh aplikasi aktor Anda.

Cobalah menjalankan kode sederhana berikut untuk membuat 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()
  }
}

Mendefinisikan Perilaku Aktor

Perilaku aktor menentukan cara aktor tersebut bereaksi terhadap berbagai pesan. Dalam Scala, Anda mendefinisikannya dengan memperluas sifat Actor dan mengimplementasikan metode receive.

Metode receive adalah fungsi parsial yang mencocokkan pesan masuk dengan tindakan tertentu.
Setiap aktor memproses pesan satu per satu secara berurutan, sehingga keamanan utas untuk status internalnya tetap terjamin.

ActorRef: Alamat Aktor

Anda tidak berinteraksi langsung dengan instans aktor. Sebagai gantinya, Anda mengirim pesan ke ActorRef. Anggaplah ActorRef sebagai alamat pos untuk sebuah aktor.

Ini adalah pegangan yang mewakili aktor tertentu dalam sistem.
Pesan yang dikirim ke ActorRef ditempatkan di kotak surat aktor.
Anda memperoleh ActorRef saat membuat aktor menggunakan actorOf.

Mengirim Pesan ke Aktor

Cara utama aktor berkomunikasi adalah dengan mengirim pesan. Cara paling umum untuk mengirim pesan adalah menggunakan metode ! (dibaca sebagai 'kirim').

receiverActorRef ! "Your message here"

Metode tell bersifat asinkron dan tidak menunggu balasan. Metode ini mengirim pesan tanpa menunggu balasan.

Mari gabungkan pembuatan aktor dan pengiriman pesan kepadanya:

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

Membuat Aktor Anak

Aktor dapat membuat aktor lain, sehingga membentuk hierarki yang telah kita bahas. Aktor induk membuat aktor anaknya menggunakan context.actorOf.

context.actorOf: Digunakan oleh aktor untuk membuat aktor anaknya.
system.actorOf: Digunakan oleh aplikasi untuk membuat aktor tingkat atas (penjaga).

Pembuatan aktor anak membantu menata sistem, mendelegasikan tugas, dan mengisolasi kegagalan.

Komunikasi Induk-Anak

Aktor berkomunikasi dengan mengirim pesan ke ActorRef satu sama lain. Aktor anak dapat memperoleh ActorRef induknya melalui context.parent. Untuk membalas pengirim pesan, aktor dapat menggunakan sender().

Mari lihat contoh ketika induk membuat anak, memintanya mengerjakan tugas, lalu anak melaporkan kembali setelah selesai:

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

Menghentikan Aktor dengan Benar

Aktor sebaiknya dihentikan dengan benar ketika tidak lagi diperlukan agar sumber daya dapat dilepaskan. Anda dapat menghentikan aktor dengan beberapa cara:

context.stop(self): Aktor menghentikan dirinya sendiri.
context.stop(childRef): Induk menghentikan salah satu anaknya.
system.stop(actorRef): Digunakan untuk aktor tingkat atas, meskipun biasanya Anda menghentikan seluruh sistem.

Saat aktor berhenti, aktor tersebut memproses semua pesan di kotak suratnya sebelum berhenti sepenuhnya. Anak-anaknya juga dihentikan secara rekursif.

Pemeriksaan Singkat: Perancangan Aktor

Perhatikan potongan kode aktor Akka berikut. Apa cara yang benar bagi MyChildActor untuk mengirim pesan kembali kepada induk pembuatnya, MyParentActor, jika MyParentActor adalah pengirim pesan 'request' awal?

Rangkuman: Merancang Sistem Aktor

Kerja bagus! Dalam pelajaran ini, kita telah membahas aspek-aspek penting dalam merancang Sistem Aktor Akka:

Aktor diatur dalam hierarki, yang sangat penting untuk supervisi dan struktur.
ActorSystem adalah titik masuk aplikasi Anda ke Akka.
Anda mendefinisikan perilaku aktor menggunakan metode receive.
ActorRef adalah alamat untuk mengirim pesan.
Aktor berkomunikasi secara asinkron menggunakan metode ! (kirim).
Induk membuat anak dengan context.actorOf, dan anak dapat membalas menggunakan sender().
Aktor dapat dihentikan dengan benar menggunakan context.stop().

Selanjutnya, kita akan membahas lebih dalam strategi supervisi Akka yang tangguh dan cara menangani kegagalan dengan benar!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Merancang Sistem Aktor” gratis?

Ya — teks lengkap “Merancang Sistem Aktor” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Merancang Sistem Aktor”?

Pelajari cara merancang dan menerapkan hierarki aktor, mendefinisikan perilaku aktor, serta mengirim dan menerima pesan. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 3.

Berapa lama pelajaran “Merancang Sistem Aktor” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming