कैसे पता करने के लिए यदि किसी कलाकार निष्क्रिय

Question

मैं नौकरियों की संख्या ज्ञात नहीं अभिनेताओं में से एक में जाना जाता है (बेशक) संख्या से क्रियान्वित किया जाना है। एक अभिनेता नौकरी पूरा करने के बाद प्रारंभिक नौकरियों की संख्या में वृद्धि हो सकती है। यही है, एक अभिनेता, अपने कार्य को पूरा करने पर, निष्पादित करने के लिए एक नया काम जोड़ सकता है।

तरह से मैं यह प्रत्येक अभिनेता निष्पादन के परिणाम के साथ लेकिन यह भी एक 'ध्वज' का संकेत के साथ न केवल स्वामी के पास वापस एक संदेश भेजने जब यह अपना काम पूरा करता है, है से निपटने रहा हूँ कि अभिनेता अब निष्क्रिय है । मास्टर के पास नौकरियों की कतार और निष्क्रिय अभिनेताओं की कतार है, जब भी कोई अभिनेता 'नौकरी पूरा संदेश' भेजता है तो मास्टर जांच करेगा कि क्या उस अभिनेता के लिए कुछ और है ... तो नौकरियों की कतार तक खाली है और आइडल्स की कतार पूर्ण है ... उस बिंदु पर मैंने सिस्टम को बंद कर दिया। यहां कोई अधिक पर्यवेक्षण नहीं है, इसलिए मुझे लगता है कि मैं इसे ठीक से नहीं कर रहा हूं ...

मैं राउटर का उपयोग नहीं कर रहा हूं क्योंकि मुझे निष्क्रिय अभिनेताओं के लिए राउटर से पूछने का कोई तरीका नहीं मिला, इसलिए मेरा प्रश्न है:

अक्का में ऊपर वर्णित स्थिति को संभालने का 'उचित' तरीका क्या है?

Answer 1

आपको Akka's routing capabilites.SmallestMailboxRouter पर एक नज़र डालना चाहिए जो आप खोज रहे हैं।

वैकल्पिक रूप से, तुम सिर्फ मांग है, यानी हर काम के लिए पर अभिनेताओं बना सकते हैं, एक नए अभिनेता डायनामिक रूप से तैयार किया गया है। एक केंद्रीय अभिनेता वर्तमान में सक्रिय सभी कलाकारों का ट्रैक रखता है। एक बार एक कार्यकर्ता अभिनेता किया जाता है, यह अपने आप में एक PoisonPill भेजता है और उसके बंद के बारे में मास्टर को सूचित (सक्रिय रूप से, या मानक Terminate संदेश यह है कि अक्का पर्यवेक्षण अभिनेता के लिए भेज देंगे के माध्यम से)। एक बार जब कोई सक्रिय अभिनेता नहीं होता है, यानी कोई और कार्य नहीं होता है, तो नियंत्रक अभिनेता सिस्टम को बंद कर देता है। टिप्पणी को पढ़ने के बाद

अलावा: SmallestMailboxLike, एक स्काला विशेषता SmallestMailboxRouter द्वारा में मिश्रित के स्रोतों पर एक नजर डालें। चेतावनी: आपको स्कैला का मूल ज्ञान होना चाहिए। लेकिन यह आम तौर पर वैसे भी एक अच्छा विचार है आप अक्का उपयोग करना चाहते हैं ... विधि isProcessingMessage(ActorRef)isNotIdle(ActorRef)

// Returns true if the actor is currently processing a message. 
// It will always return false for remote actors. 
// Method is exposed to subclasses to be able to implement custom 
// routers based on mailbox and actor internal state. 
protected def isProcessingMessage(a: ActorRef): Boolean = a match { 
    case x: LocalActorRef ? 
    val cell = x.underlying 
    cell.mailbox.isScheduled && cell.currentMessage != null 
    case _ ? false 
} 

// Returns true if the actor currently has any pending messages 
// in the mailbox, i.e. the mailbox is not empty. 
// It will always return false for remote actors. 
// Method is exposed to subclasses to be able to implement custom 
// routers based on mailbox and actor internal state. 
protected def hasMessages(a: ActorRef): Boolean = a match { 
    case x: LocalActorRef ? x.underlying.mailbox.hasMessages 
    case _    ? false 
} 

Answer 2

एक और रणनीति (एक "पूल" अभिनेता के रूप में एक BalancingDispatcher और एक RoundRobinRouter उपयोग करने के लिए हो सकता है के रूप में समझा जा सकता है अगर)। अक्का डॉक्स से:

BalancingDispatcher 
# This is an executor based event driven dispatcher that will try to redistribute work from busy actors to idle actors. 




# All the actors share a single Mailbox that they get their messages from. 

It is assumed that all actors using the same instance of this dispatcher can process all messages that have been sent to one of the actors; i.e. the actors belong to a pool of actors, and to the client there is no guarantee about which actor instance actually processes a given message. 

# Sharability: Actors of the same type only 

# Mailboxes: Any, creates one for all Actors 

# Use cases: Work-sharing 

application.conf में अपने प्रेषक को परिभाषित करें या स्टार्टअप पर प्रोग्राम के रूप में इसे लोड।

private final static Config akkaConfig = ConfigFactory.parseString(

      "my-dispatcher.type = BalancingDispatcher \n" + 
      "my-dispatcher.executor = fork-join-executor \n" + 
      "my-dispatcher.fork-join-executor.parallelism-min = 8 \n" + 
      "my-dispatcher.fork-join-executor.parallelism-factor = 3.0 \n" + 
      "my-dispatcher.fork-join-executor.parallelism-max = 64 " 
); 

फिर मार्गों के लिए राउटर और प्रेषक को परिभाषित करें।

getContext().actorOf(new Props(MyActor.class).withRouter(new RoundRobinRouter(10)).withDispatcher("my-dispatcher"), "myActor"); 

तो रूटर बस "वितरण" संदेशों पर जाना होगा, और डिस्पैचर एक चयनित अभिनेता चलेगा (और यह काम लागू करता है और साथ ही चोरी)

Answer 3

डिस्पैचर संतुलन सभी के लिए केवल एक ही मेलबॉक्स का उपयोग करेगा बनाए गए अभिनेता जो सभी BalancingDispatcher के साथ बनाए गए हैं। तो यह आपके काम को सरल बना देगा।