अक्का अभिनेता - किसी संदेश की अपेक्षा करने के लिए कुछ समय प्रतीक्षा करें, अन्यथा

Question

पर एक संदेश भेजें, क्या Actor किसी भी संदेश को प्राप्त करने के लिए एक्स राशि की प्रतीक्षा करना संभव है, और यदि कोई संदेश प्राप्त होता है, तो इसे सामान्य रूप से संसाधित करें, अन्यथा किसी अन्य Actor (निर्माता में पूर्व निर्धारित) को एक संदेश भेजें?

Answer 1

हाँ, यदि आप के लिए प्रतीक्षा करने के लिए किसी भी संदेश चाहते हैं, तो आप बस सेट एक receiveTimeout: http://doc.akka.io/docs/akka/current/scala/actors.html#receive-timeout

(डॉक्स है

import akka._ 
import actor._ 
import util._ 
import duration._ 
import Impatient._ 

object Impatient { 
    sealed trait State 
    case object WaitingForMessage extends State 
    case object MessageReceived extends State 
    case object TimeoutExpired extends State 

    sealed trait Data 
    case object Unitialized extends Data 

    // In 
    case object Message 
} 

class Impatient(receiver: ActorRef) extends Actor with FSM[State, Data] { 
    startWith(WaitingForMessage, Unitialized) 

    when(WaitingForMessage, stateTimeout = 3 seconds) { 
    case Event(StateTimeout, data) => goto(TimeoutExpired) using data // data is usually modified here 
    case Event(Message, data) => goto(MessageReceived) using data // data is usually modified here 
    } 

    onTransition { 
    case WaitingForMessage -> MessageReceived => stateData match { 
     case data => log.info("Received message: " + data) 
    } 
    case WaitingForMessage -> TimeoutExpired => receiver ! TimeoutExpired 
    } 

    when(MessageReceived) { 
    case _ => stay 
    } 

    when(TimeoutExpired) { 
    case _ => stay 
    } 

    initialize 
} 

यहाँ यह कार्रवाई में है यहां थोड़ा भ्रामक, आप प्रत्येक संदेश के बाद प्राप्त टाइमआउट भी सेट कर सकते हैं)

Answer 2

यह संभव है, Akka Actor "ask" and "Await" with TimeoutException पर एक नज़र डालें। लेकिन ध्यान रखें कि एक अभिनेता के अंदर अवरुद्ध करना एक बहुत बुरा विचार है क्योंकि उस समय अभिनेता किसी अन्य संदेश को संभाल नहीं सकता है। इसके अलावा यह एक अक्का प्रसंस्करण धागा को अवरुद्ध करता है।

एक बेहतर तरीका एक संदेश भेजने के लिए है (आग और भूलें) और Akka scheduler का उपयोग करके कुछ टाइमआउट ईवेंट शेड्यूल करें। जब प्रतिक्रिया आती है, तो उस ईवेंट को रद्द करें या कुछ झंडा सेट करें ताकि उत्तर वास्तव में समय पर आने पर यह ट्रिगर नहीं होगा।

Answer 3

एक ओवरकिल हो सकता है, लेकिन आप Finite State Machine (FSM) विशेषता देख सकते हैं।

object Main extends App { 
    import akka._ 
    import actor._ 
    import Impatient._ 

    val system = ActorSystem("System") 

    val receiver = system.actorOf(Props(new Actor with ActorLogging { 
    def receive = { 
     case TimeoutExpired => log.warning("Timeout expired") 
    } 
    })) 

    val impatient = system.actorOf(Props(new Impatient(receiver)), name = "Impatient") 
    impatient ! Message 

    val impatient2 = system.actorOf(Props(new Impatient(receiver)), name = "Impatient2") 
    Thread.sleep(4000) 
    impatient2 ! Message 

    system.shutdown() 
}