0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Dasar-Dasar Model Aktor Akka

Pahami prinsip Model Aktor, siklus hidup aktor, dan pengiriman pesan untuk eksekusi konkuren.

Dasar-Dasar Model Aktor Akka adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 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.

Menghadapi Tantangan Konkuren

Dalam aplikasi modern, tugas sering kali perlu dijalankan secara bersamaan. Ini disebut konkurensi. Meskipun bermanfaat, konkurensi juga menghadirkan berbagai tantangan.

  • Kondisi balapan: Terjadi ketika beberapa utas mencoba mengakses dan mengubah data bersama secara bersamaan, sehingga menghasilkan keluaran yang tidak dapat diprediksi.
  • Kebuntuan: Terjadi ketika dua utas atau lebih terblokir tanpa batas waktu karena saling menunggu untuk melepaskan sumber daya.

Model pengelolaan utas tradisional dapat menjadi rumit dan rentan terhadap kesalahan saat menangani masalah ini.

Memahami Model Aktor

Model Aktor menawarkan cara yang andal untuk mengelola konkurensi. Alih-alih berbagi memori, aktor hanya berkomunikasi dengan saling mengirim pesan.

  • Isolasi: Setiap aktor memiliki status privatnya sendiri yang tidak dapat diakses langsung oleh aktor lain.
  • Pertukaran pesan: Aktor berinteraksi dengan mengirim pesan yang tidak dapat diubah ke kotak pesan satu sama lain.
  • Asinkron: Pengiriman pesan tidak memblokir; pengirim tidak menunggu balasan.

Bayangkan aktor sebagai orang-orang yang berdiri sendiri, masing-masing memiliki meja sendiri (status) dan layanan pos (pertukaran pesan).

Mengapa Memilih Akka?

Akka adalah perangkat sumber terbuka yang menerapkan Model Aktor dalam Scala (dan Java). Akka dirancang untuk membangun aplikasi yang sangat konkuren, terdistribusi, dan toleran terhadap kesalahan.

  • Kesederhanaan: Akka menyederhanakan pemrograman konkuren dengan menyembunyikan detail pengelolaan utas tingkat rendah.
  • Skalabilitas: Aplikasi dapat dengan mudah ditingkatkan dari satu mesin menjadi gugus mesin.
  • Ketangguhan: Menyediakan mekanisme bawaan untuk menangani kegagalan, sehingga sistem dapat memulihkan diri.

Akka membantu Anda menulis sistem yang "tetap berjalan" bahkan saat menghadapi beban berat atau kegagalan sebagian.

Di Dalam Aktor Akka

Aktor Akka adalah unit dasar konkurensi. Setiap aktor memiliki:

  • Perilaku: Ditentukan oleh cara aktor merespons pesan.
  • Kotak pesan: Tempat pesan masuk diantrekan. Pesan diproses satu per satu, sesuai urutan.
  • Status privat: Data yang sepenuhnya dimiliki aktor dan hanya dapat diubah oleh aktor itu sendiri.
  • ActorRef: Alamat unik untuk mengirim pesan kepada aktor ini.

Isolasi yang ketat ini mencegah bug konkurensi umum seperti kondisi balapan.

ActorSystem Pertama Anda

Sebelum dapat membuat aktor, Anda memerlukan ActorSystem. Ini adalah titik masuk untuk Akka yang mengelola semua aktor dalam cakupannya.

ActorSystem menyediakan layanan seperti penjadwalan, konfigurasi, dan hierarki untuk pengawasan (yang akan kita bahas nanti).

Cobalah membuatnya:

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

Membuat Aktor Pertama Anda

Untuk membuat aktor, Anda mendefinisikan kelas yang memperluas sifat Actor milik Akka dan mengimplementasikan metode receive.

Metode receive menentukan cara aktor memproses pesan masuk. Metode ini merupakan fungsi parsial yang mencocokkan jenis pesan.

import akka.actor.Actor

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

Membuat Aktor & ActorRef

Aktor dibuat (atau "dimunculkan") menggunakan metode actorOf dari ActorSystem. Metode ini mengembalikan ActorRef.

ActorRef adalah pegangan ringan yang dapat diserialisasi untuk sebuah aktor. Anda menggunakannya untuk mengirim pesan kepada aktor tersebut, bukan berinteraksi langsung dengan instans aktornya.

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

Mengirim Pesan kepada Aktor

Komunikasi antaraktor berlangsung secara eksklusif melalui pesan. Anda mengirim pesan ke ActorRef menggunakan operator ! (kirim).

Pesan dikirim secara asinkron dan biasanya berupa kelas kasus yang tidak dapat diubah atau tipe sederhana seperti 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()
}

Dasar-Dasar Siklus Hidup Aktor

Aktor memiliki siklus hidup, mulai dari pembuatan hingga penghentian. Akka menyediakan kait agar Anda dapat melakukan tindakan penyiapan dan pembersihan:

  • preStart(): Dipanggil tepat sebelum aktor mulai memproses pesan pertamanya. Berguna untuk menginisialisasi sumber daya.
  • postStop(): Dipanggil setelah aktor berhenti dan sebelum aktor sepenuhnya dihapus dari sistem. Berguna untuk melepaskan sumber daya.

Memahami siklus hidup sangat penting untuk mengelola sumber daya aktor secara efektif.

Hierarki Aktor

Aktor diatur dalam hierarki, mirip seperti sistem berkas. Setiap aktor, kecuali aktor "penjaga akar", memiliki induk.

  • Supervisi: Aktor induk bertanggung jawab mengawasi aktor anaknya. Jika aktor anak gagal, induknya menentukan cara menangani kegagalan tersebut, misalnya memulai ulang atau menghentikannya.
  • Jalur: Setiap aktor memiliki jalur unik, seperti /user/myActor/childActor, yang mencerminkan posisinya dalam hierarki.

Hierarki ini merupakan kunci bagi fitur toleransi kesalahan dan ketahanan Akka.

Pemeriksaan Dasar-Dasar Akka

Mari uji pemahaman Anda tentang dasar-dasar Model Aktor Akka.

Rangkuman: Model Aktor Akka

Kerja bagus! Dalam pelajaran ini, Anda telah mempelajari konsep-konsep dasar Model Aktor Akka:

  • Tantangan konkurensi tradisional.
  • Prinsip Model Aktor: isolasi, pengiriman pesan, dan tidak adanya status bersama.
  • Peran Akka sebagai perangkat untuk membangun sistem aktor yang tangguh.
  • Cara mendefinisikan ActorSystem dan aktor sederhana dalam Scala.
  • Cara membuat aktor dan mengirimi mereka pesan menggunakan ActorRef.
  • Dasar-dasar siklus hidup dan hierarki aktor.

Selanjutnya, kita akan membahas lebih dalam perancangan sistem aktor dan penanganan interaksi yang lebih kompleks!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Dasar-Dasar Model Aktor Akka” gratis?

Ya — teks lengkap “Dasar-Dasar Model Aktor Akka” 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 “Dasar-Dasar Model Aktor Akka”?

Pahami prinsip Model Aktor, siklus hidup aktor, dan pengiriman pesan untuk eksekusi konkuren. 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 1 dari 3.

Berapa lama pelajaran “Dasar-Dasar Model Aktor Akka” 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

  1. Dasar-Dasar Model Aktor Akka
  2. Merancang Sistem Aktor
  3. Supervisi dan Toleransi Kesalahan
← Kembali ke Scala for Backend Engineering & Functional Programming