Scala for Backend Engineering & Functional Programming · Ders

Aktör Sistemleri Tasarlama

Aktör hiyerarşileri tasarlamayı ve uygulamayı, aktör davranışlarını tanımlamayı ve iletileri gönderip almayı öğrenin.

2. ders / 311 adım

Aktör Sistemleri Tasarlama, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 3 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Scala for Backend Engineering & Functional Programming öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Scala for Backend Engineering & Functional Programming kursu toplamda 3 dersten oluşur.

Aktör Sistemleri Tasarlama: Giriş

2. derse hoş geldiniz! Önceki derste Akka Aktör Modeli'nin temellerini öğrendik. Şimdi Akka aktör sistemlerini tasarlamayı inceleyelim.

İyi tasarlanmış bir aktör sistemi sağlam, ölçeklenebilir ve bakımı kolaydır. Aktörlerinizi nasıl yapılandıracağınızı, davranışlarını nasıl tanımlayacağınızı ve etkili bir şekilde iletişim kurmalarını nasıl sağlayacağınızı keşfedeceğiz.

Aktör Hiyerarşilerini Anlamak

Akka aktörleri, dosya sistemine çok benzeyen ağaç benzeri bir hiyerarşi içinde düzenlenir. 'Kök' aktör dışındaki her aktörün bir üst aktörü vardır.

Üst-Alt İlişkisi: Başka bir aktör oluşturan aktör, oluşturduğu aktörün üst aktörü olur.
Denetim: Bu hiyerarşi, Akka'nın hata toleransı açısından kritik öneme sahiptir. Üst aktörler, alt aktörlerini denetlemekten sorumludur (bunu sonraki derste daha ayrıntılı ele alacağız!).
Yol Tabanlı Adresleme: Her aktörün, hiyerarşideki konumunu gösteren /user/parentActor/childActor gibi benzersiz bir yolu vardır.

ActorSystem Kurulumu

ActorSystem, tüm Akka uygulamalarının giriş noktasıdır. İş parçacığı havuzları ve zamanlayıcılar da dâhil olmak üzere aktörler için gereken kaynakları yönetir.

Uygulama başına bir kez oluşturur ve ardından en üst düzey aktörlerinizi oluşturmak için kullanırsınız. Bu, tüm aktör uygulamanızın kapsayıcısı gibidir.

Bir ActorSystem oluşturmak için bu basit kodu çalıştırmayı deneyin:

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

Aktör Davranışını Tanımlama

Bir aktörün davranışı, farklı iletilere nasıl tepki vereceğini belirler. Scala'da bunu, Actor özelliğini genişleterek ve receive metodunu uygulayarak tanımlarsınız.

receive metodu, gelen iletileri belirli eylemlerle eşleştiren bir kısmi işlevdir.
Her aktör, dahili durumunun iş parçacığı açısından güvenli olmasını sağlamak için iletileri teker teker ve sıralı olarak işler.

ActorRef: Aktörün Adresi

Aktör örnekleriyle doğrudan etkileşime girmezsiniz. Bunun yerine iletileri bir ActorRef'e gönderirsiniz. ActorRef'i bir aktörün posta adresi gibi düşünebilirsiniz.

Sistem içindeki belirli bir aktörü temsil eden bir başvurudur.
Bir ActorRef'e gönderilen iletiler, aktörün ileti kutusuna yerleştirilir.
actorOf kullanarak bir aktör oluşturduğunuzda bir ActorRef elde edersiniz.

Aktörlere İleti Gönderme

Aktörlerin iletişim kurmasının temel yolu ileti göndermektir. İleti göndermenin en yaygın yolu ! ("tell" olarak telaffuz edilir) metodunu kullanmaktır.

receiverActorRef ! "Your message here"

tell metodu eşzamansızdır ve gönderip beklememe yaklaşımını kullanır. İletiyi gönderir ve yanıt beklemez.

Bir aktör oluşturmayı ve ona ileti göndermeyi birlikte görelim:

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

Alt Aktörler Oluşturma

Aktörler, ele aldığımız hiyerarşiyi oluşturarak başka aktörler yaratabilir. Bir üst aktör, alt aktörlerini context.actorOf kullanarak oluşturur.

context.actorOf: Bir aktörün alt aktörlerini oluşturmak için kullanılır.
system.actorOf: Uygulama tarafından en üst düzey (koruyucu) aktörleri oluşturmak için kullanılır.

Alt aktörler oluşturmak, sisteminizi düzenlemenize, görevleri devretmenize ve hataları yalıtmanıza yardımcı olur.

Üst ve Alt Aktörler Arasında İletişim

Aktörler, birbirlerinin ActorRef'lerine ileti göndererek iletişim kurar. Bir alt aktör, üst aktörünün ActorRef'ini context.parent aracılığıyla alabilir. Bir aktör, iletinin göndericisine yanıt vermek için sender() kullanabilir.

Bir üst aktörün alt aktör oluşturduğu, ona iş yapmasını söylediği ve alt aktörün iş tamamlandığında geri bildirim verdiği bir örneğe bakalım:

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

Aktörleri Sorunsuz Bir Şekilde Durdurma

Aktörlere artık ihtiyaç kalmadığında kaynakları serbest bırakmak için sorunsuz bir şekilde durdurulmaları gerekir. Bir aktörü birkaç şekilde durdurabilirsiniz:

context.stop(self): Aktör kendisini durdurur.
context.stop(childRef): Bir üst aktör, alt aktörlerinden birini durdurur.
system.stop(actorRef): En üst düzey aktörler için kullanılır; ancak genellikle tüm sistemi durdurursunuz.

Bir aktör durduğunda sonlandırılmadan önce ileti kutusundaki tüm iletileri işler. Alt aktörleri de özyinelemeli olarak durdurulur.

Hızlı Kontrol: Aktör Tasarımı

Aşağıdaki Akka aktör kodu parçasını inceleyin. MyParentActor başlangıçtaki 'request' iletisinin göndericisi olduysa, MyChildActor'ın kendisini oluşturan üst aktör MyParentActor'a ileti göndermesinin doğru yolu nedir?

İnteraktif derste cevapla

Özet: Aktör Sistemleri Tasarlama

Harika iş çıkardınız! Bu derste Akka aktör sistemlerini tasarlamanın temel yönlerini ele aldık:

Aktörler, denetim ve yapı açısından hayati önem taşıyan hiyerarşiler içinde düzenlenir.
ActorSystem, uygulamanızın Akka'ya giriş noktasıdır.
Aktör davranışını receive metodunu kullanarak tanımlarsınız.
ActorRef, ileti göndermek için kullanılan adrestir.
Aktörler, ! (tell) metodunu kullanarak eşzamansız iletişim kurar.
Üst aktörler context.actorOf ile alt aktörler oluşturur; alt aktörler de sender() kullanarak yanıt verebilir.
Aktörler context.stop() kullanılarak sorunsuz bir şekilde durdurulabilir.

Sırada, Akka'nın güçlü denetim stratejilerini ve hataların sorunsuz bir şekilde nasıl ele alınacağını daha ayrıntılı inceleyeceğiz!

Başlamak ücretsiz

Yapay zeka eğitmeniyle Scala öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 39
Dersler: 143

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“Aktör Sistemleri Tasarlama” dersi ücretsiz mi?

Evet — “Aktör Sistemleri Tasarlama” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Scala for Backend Engineering & Functional Programming kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Scala for Backend Engineering & Functional Programming kursu toplamda 3 dersten oluşur.

“Aktör Sistemleri Tasarlama” dersinde ne öğreneceğim?

Aktör hiyerarşileri tasarlamayı ve uygulamayı, aktör davranışlarını tanımlamayı ve iletileri gönderip almayı öğrenin. Scala for Backend Engineering & Functional Programming ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Scala for Backend Engineering & Functional Programming öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Scala for Backend Engineering & Functional Programming, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 3 dersinin 2. dersidir.

“Aktör Sistemleri Tasarlama” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Scala for Backend Engineering & Functional Programming dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Scala for Backend Engineering & Functional Programming dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Scala for Backend Engineering & Functional Programming Sayfasına Dön