बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala · पाठ

Actor प्रणालियों का डिज़ाइन

actor पदानुक्रमों का डिज़ाइन और कार्यान्वयन करना, actor व्यवहार परिभाषित करना तथा संदेश भेजना और प्राप्त करना सीखें।

पाठ 2, कुल 3 में से11 चरण

Actor प्रणालियों का डिज़ाइन, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 3 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 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 को भेजे गए संदेश एक्टर के मेलबॉक्स में रखे जाते हैं।
actorOf का उपयोग करके एक्टर बनाते समय आपको ActorRef प्राप्त होता है।

एक्टरों को संदेश भेजना

एक्टरों के संचार का मुख्य तरीका संदेश भेजना है। संदेश भेजने का सबसे सामान्य तरीका ! (जिसका उच्चारण '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 को संदेश भेजकर संचार करते हैं। कोई चाइल्ड एक्टर context.parent के माध्यम से अपने पैरेंट का ActorRef प्राप्त कर सकता है। संदेश भेजने वाले को उत्तर देने के लिए कोई एक्टर 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 एक्टर कोड अंश पर विचार करें। यदि प्रारंभिक 'request' संदेश भेजने वाला MyParentActor था, तो MyChildActor के लिए अपने बनाने वाले पैरेंट MyParentActor को संदेश वापस भेजने का सही तरीका क्या है?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: एक्टर सिस्टम का डिज़ाइन

बहुत अच्छा! इस पाठ में हमने Akka एक्टर सिस्टम के डिज़ाइन से जुड़े महत्वपूर्ण पहलुओं को समझा:

एक्टरों को पदानुक्रमों में व्यवस्थित किया जाता है, जो पर्यवेक्षण और संरचना के लिए अत्यंत महत्वपूर्ण हैं।
ActorSystem आपके अनुप्रयोग का Akka के लिए प्रवेश-बिंदु है।
आप receive विधि का उपयोग करके एक्टर का व्यवहार परिभाषित करते हैं।
संदेश भेजने के लिए ActorRef पता होता है।
एक्टर ! (tell) विधि का उपयोग करके अतुल्यकालिक रूप से संचार करते हैं।
पैरेंट context.actorOf से चाइल्ड बनाते हैं और चाइल्ड sender() का उपयोग करके उत्तर दे सकते हैं।
एक्टरों को context.stop() का उपयोग करके सुचारु रूप से रोका जा सकता है।

अगले पाठ में हम Akka की शक्तिशाली पर्यवेक्षण रणनीतियों और विफलताओं को सुचारु रूप से संभालने के तरीकों को विस्तार से समझेंगे!

शुरुआत निःशुल्क

एआई शिक्षक के साथ Scala सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 39
पाठ: 143

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Actor प्रणालियों का डिज़ाइन” पाठ निःशुल्क है?

हाँ—“Actor प्रणालियों का डिज़ाइन” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 3 पाठ शामिल हैं।

“Actor प्रणालियों का डिज़ाइन” में मैं क्या सीखूँगा?

actor पदानुक्रमों का डिज़ाइन और कार्यान्वयन करना, actor व्यवहार परिभाषित करना तथा संदेश भेजना और प्राप्त करना सीखें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 3 में से 2वाँ पाठ है।

“Actor प्रणालियों का डिज़ाइन” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पर वापस जाएँ