कांटा और अक्का

Question

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

तो मैं अपने सुरक्षाप्रोसेसर (जो एक अभिनेता है) संदेश भेजता हूं, और पूरा करने के लिए सभी वायदा पर इंतजार करता है। अंत में मैं पोस्ट-प्रोसेसिंग करने के लिए मर्जहेल्पर का उपयोग करता हूं। SecurityProcessor एक सुरक्षा लेता है, कुछ मैं/हे और प्रसंस्करण करता है और उत्तर एक सुरक्षा

val listOfFutures = new ListBuffer[Future[Security]]() 
    var portfolioResponse: Portfolio = _ 
    for (security <- portfolio.getSecurities.toList) { 
    val securityProcessor = actorOf[SecurityProcessor].start() 
    listOfFutures += (securityProcessor ? security) map { 
     _.asInstanceOf[Security] 
    } 
    } 
    val futures = Future.sequence(listOfFutures.toList) 
    futures.map { 
    listOfSecurities => 
     portfolioResponse = MergeHelper.merge(portfolio, listOfSecurities) 
    }.get 

इस डिजाइन सही है, और वहाँ एक बेहतर/कूलर अक्का का उपयोग कर इस आम समस्या को लागू करने के तरीका है?

Answer 1

val futureResult = Future.sequence(
        portfolio.getSecurities.toList map { security => (actorOf[SecurityProcessor].start() ? security).mapTo[Security] } 
       ) map { securities => MergeHelper.merge(portfolio, securities) }