स्कैला रिमोट एक्टर्स

Question

क्या कोई गाइड या ट्यूटोरियल हैं जो स्कैला कलाकारों को दूरस्थ रूप से उपयोग करने की संभावना बताते हैं? सब कुछ मैंने पाया है अब तक एक उदाहरण है (टिप्पणियों के बिना) लेकिन यह शायद ही पर्याप्त है।

Answer 1

मैंने कुछ समय पहले an article with an example app to explain the use of Remote Actors लिखा है।

ठीक है, इस कोड के अंदर कोई टिप्पणी नहीं है (शायद आप उस लेख का भी अर्थ है), लेकिन कोड के नीचे स्पष्टीकरण हैं।

Answer 2

इनमें से कोई भी मुझे पता नहीं है। यह बहुत अधिक है "जंगल के माध्यम से अपना रास्ता हैक" दृष्टिकोण। एपीआई से निर्णय लेते हुए, चीजों को नियमित अभिनेताओं के समान ही काम करना चाहिए, जिसके लिए एक या दो ट्यूटोरियल मौजूद हैं (साथ ही साथ कुछ किताबें)।

यदि आप रिमोट एक्टर्स का उपयोग करते हैं, तो हम (समुदाय) निश्चित रूप से अनुभवी उपयोगकर्ता से ऐसे ट्यूटोरियल का स्वागत करेंगे!

Answer 3

बस उन संदेशों को भेजने के लिए सावधान रहें जो serializable (केस क्लास और केस ऑब्जेक्ट्स हैं!) और सुनिश्चित करें कि विपरीत पक्ष कक्षा बना सकता है। कस्टम क्लासलोडर्स के लिए देखें या क्लासपाथ में जेएआर खो रहे हैं।

Answer 4

अक्का ढांचे में remote actors है। एपीआई नियमित स्कैला कलाकारों के समान ही है।

वे स्वचालित क्लस्टरिंग के कुछ स्तर भी प्रदान करते हैं, लेकिन यह पूरा नहीं हुआ है।

Answer 5

हाल ही में वहाँ एक गाइड www.scala-lang.org के पहले पन्ने पर जोड़ा गया है, यहाँ लिंक http://www.scala-lang.org/docu/files/actors-api/actors_api_guide.html#

Answer 6

हो सकता है कि यह एक necropost है, लेकिन मैं सब कुछ खत्म हो लिए देख रहा था और बहुत ज्यादा नहीं मिल सकता है । उम्मीद है कि यह किसी की मदद करेगा।

मैं चला रहा हूँ मैक ओएस 10.6.8 और स्काला 2.9.0.1। मुझे कैननिकल रिमोट एक्टर्स उदाहरण चलने में समस्याएं थीं। मैं निम्नलिखित कोड के साथ समाप्त हो गया।

नोट:स्पष्ट विधि सिर्फ ढेर से संदेश को रोकने के लिए है। उदाहरण के लिए यह महत्वपूर्ण नहीं है। इसी प्रकार पर कॉल थ्रेड.sleep रनटाइम पर क्या चल रहा है यह देखने में आसान है।

यह संकलित करें, तो अलग खोल उदाहरणों कार्य करें:

$> scala Ping 

और

$> scala Pong 

किसी भी क्रम में

। आप एक समय में उनमें से एक को मारकर और कोड का पता लगाकर प्रयोग कर सकते हैं।

import scala.actors._ 
import scala.actors.Actor._ 
import scala.actors.remote._ 
import scala.actors.remote.RemoteActor._ 

/** @author Connor Doyle */ 

// Remote messages must be serializable. 
// The easist way to do this is to wrap 
// them with a case class 
case class Message(text: String) 

abstract class PingPongActor extends Actor with App { 
    val pingPort = 9000 
    val pongPort = 9001 
    val delay = 1000 
    classLoader = getClass().getClassLoader() // hack! 
    start 

    // this method consumes all pending messages 
    // the library should have implemented an atomic 
    // receiveAndClear operation 
    def clear: Unit = receiveWithin(0) { 
     case TIMEOUT =>() 
     case _ => clear 
    } 
} 

object Ping extends PingPongActor { 

    // result of select already lazy, but explicit lazy conveys 
    // semantics clearly 
    lazy val pong = select(Node("localhost", pongPort), 'pong) 

    def act = { 
     alive(pingPort) 
     register('ping, self) 
     loop { 
      pong ! Message("ping") 
      receiveWithin(delay * 2) { 
       case Message(text: String) => { 
        clear 
        println("received: "+text) 
        Thread.sleep(delay) // wait a while 
       } 
       case TIMEOUT => println("ping: timed out!") 
      } 
     } 
    } 
} 

object Pong extends PingPongActor { 

    lazy val ping = select(Node("localhost", pingPort), 'ping) 

    def act = { 
     alive(pongPort) 
     register('pong, self) 
     loop { 
      receiveWithin(delay * 2) { 
       case Message(text: String) => { 
        println("received: "+text) 
        Thread.sleep(delay) // wait a while 
        clear 
        ping ! Message("pong") 
       } 
       case TIMEOUT => println("pong: timed out") 
      } 
     } 
    } 
} 

चीयर्स!