scala अभिनेता के बाहर अक्का अभिनेता के साथ बातचीत करें




asynchronous akka (3)

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

इसके अलावा, मेरा मानना ​​है कि इनबॉक्स सामग्री का उल्लेख आप आरईपीएल में अभिनेता सामान का परीक्षण करने के लिए तैयार हैं (कम से कम यह है कि एक्टोरडीएसएल पर डॉक्स) अभिनेता के बाहर से पूछने का उपयोग करने के दृष्टिकोण के साथ रहें अक्का को अल्पावधि अभिनेता बना दें कि उसे गैर-अभिनेता के अभिनेता कॉल के लिए हुड के तहत संचार की जरूरत है। तो बस एक गैर अवरुद्ध कॉलबैक पर स्विच करें जैसा मैंने ऊपर सुझाव दिया था मेरा विश्वास है कि आप जो चाहते हैं वह है।

मैं अपने धागे से अक्का अभिनेताओं के साथ बातचीत करना चाहता हूं। वर्तमान में, मैं ऐसा करता हूं:

val res = Await.result(aref ? GroupReceive(fromRank), timeout.duration).asInstanceOf[T]

लेकिन मुझे यह अनिश्चित है कि यह कैसे वास्तव में मेरे धागे से संपर्क करता है? मैं प्राप्त करने के लिए एसिंक्रोनस होने की इच्छा करता हूं, यानी मैं किसी दूसरे काम को करने की अनुमति प्राप्त करते समय धागा को लटका देना चाहता हूं। मैंने हाल ही में अकाका इनबॉक्स सिस्टम के बारे में पढ़ा है इनबॉक्स अकाखा एपीआई

मुझे लगता है मुझे याद है कि प्रतीक्षा हर बार एक नए अभिनेता बनाता है इंतजार के बीच मतभेद क्या हैं + पूछें और इनबॉक्स में, और क्या कोई मुझे एक इनबॉक्स कैसे बना सकता है और "बाहर" से कलाकारों के साथ संवाद करने के लिए इसका इस्तेमाल कर सकता है?

संपादित करें बस स्पष्ट करने के लिए, मैं एक ही धागा काम करना जारी रखने के लिए नहीं चाहता, मैं चाहता हूं कि इसे सीपीयू-कोर को रोकना बंद कर देना और अन्य धागे को काम करने तक छोड़ देना चाहिए, जब तक कि कुछ प्राप्त न हो जाए, फिर से जाग जाएं।


Await.receive Scala concurrency API का हिस्सा है और अभिनेताओं के साथ कुछ नहीं करना है। इसका उद्देश्य प्रक्षेपित भविष्य के पूरा होने तक मौजूदा थ्रेड को ब्लॉक करता है, या टाइमआउट सीमा में किक करती है और पूरी चीज टाइमआउट अपवाद में समाप्त होती है।

पूछने वाला ऑपरेटर ? वास्तव में एक अस्थायी अभिनेता को एक अभिनेता के उत्तर के इंतजार के इंतजार के साथ तैयार करेंगे, जो कि aref वैरिएबल और भविष्य को पूरा करने की ओर इशारा करता है जब आपने प्राप्त उत्तर के साथ पूछ ऑपरेटर को फोन किया था।

तो आपका कोड पूरी तरह से पूरे धागा को अवरुद्ध कर रहा है। जैसा कि संकेत दिया गया था, यदि आप वर्तमान धागा को मुक्त करना चाहते हैं और कुछ अन्य काम जारी रखना चाहते हैं तो आप भविष्य में एक कॉलबैक संलग्न कर सकते हैं।

implicit val ctx: ExecutionContext = //provide execution context here
implicit val timeout: Timeout = // provide timeout here
aref ? GroupReceive(fromRank)) onSuccess { res =>
   //do something with res here, asynchronously
}
// some other code which runs without being blocked...

उपर्युक्त कोड को आपके ऊपर वर्णित अभिनेता DSL के साथ फिर से लिखा जा सकता है:

import akka.actor.ActorDSL._
implicit val actorSystem: ActorSystem = // provide an actor system here or any actor ref factory

actor(new Act {
  aref ! GroupReceive(fromRank)
  context.setReceiveTimeout(timeout) //optional
  become {
    case ReceiveTimeout => {
      //handle the timeout
      context.stop(self)
    }
    case res => {
      //do your thing with res, asynchronously
      context.stop(self)
    }
  }
}

//some other code which won't wait for the above operations

उत्तरार्द्ध संस्करण भी एक नया अस्थायी अभिनेता बनाता है जो GroupReceive संदेश भेजता है और फिर एक उत्तर के लिए इंतजार करता है, उसके बाद वह खुद को मारता है

निचला रेखा यह है कि एक अभिनेता से एक संदेश प्राप्त करने के लिए आपको स्वयं एक अभिनेता होना चाहिए अभिनेता सिर्फ ActorRef अलावा किसी अन्य को संदेश नहीं भेज सकते हैं

तो या तो आप पूछना पैटर्न का उपयोग करते हैं जो पर्दे के पीछे एक अस्थायी अभिनेता बनाता है और इस अस्थायी अभिनेता के जीवनचिकित्सा का प्रबंधन करता है, जो आपके साथ काम करने के लिए सिर्फ एक अच्छा सादा भविष्य का खुलासा करता है, या फिर आप अस्थायी अभिनेता को खुद बना सकते हैं, लेकिन तब आपको प्रबंधन करना है इसकी जीवनचक्र (यानी इसे अपनी नौकरी कर लेने के बाद इसे मारना याद रखना)

विकल्प का चयन करें जो आपके लिए सबसे उपयुक्त है


जैसा कि अक्का के फ्यूचर दस्तावेज में लिखा गया है, परिणाम का इंतजार करने के लिए इंतजार करते हुए प्रतीक्षा थैंक को मौजूदा धागा ब्लॉक करता है।

उदाहरण

import scala.concurrent.Await
import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.duration._

implicit val timeout = Timeout(5 seconds)
val future = actor ? msg // enabled by the “ask” import
val result = Await.result(future, timeout.duration).asInstanceOf[String]

इससे वर्तमान धागा को ब्लॉक करने और अभिनेता को इसके उत्तर के साथ भविष्य को 'पूरा' करने के लिए इंतजार करना होगा

अभिनेता के साथ प्रयोग करें







inbox