क्या होता है जब हम स्केल कलाकारों के साथ (सत्य) के बजाय लूप का उपयोग करते हैं?

Question

अभिनेताओं के साथ प्राप्त करते समय (सत्य) के बजाए लूप का उपयोग करने में क्या अंतर है। लूप बहुत तेजी से काम करता प्रतीत होता है, लेकिन क्यों, और बोनेट के नीचे क्या चल रहा है?

क्या (सत्य) के बजाए लूप का उपयोग करने में कुछ बुरा है?

संदर्भ के बारे में अधिक जानकारी। मैं सरल पिंग/पोंग कोड के भीतर प्रदर्शन परीक्षण कर रहा हूं। और मैं प्राप्त का उपयोग कर रहा हूँ।

class ReceivePing(
     count : Int, 
     pong : Actor 
     ) extends Actor {def act() { 
var pingsLeft = count - 1 
pong ! Start 
pong ! ReceivePing 
while(true) { 
    receive { 
    case ReceivePong => 
     if (pingsLeft % 10000 == 0) 
     Console.println("ReceivePing: pong") 
     if (pingsLeft > 0) { 
     pong ! ReceivePing 
     pingsLeft -= 1 
     } else { 
     Console.println("ReceivePing: stop") 
     pong ! Stop 
     exit() 
     } 
    } 
}}} 

जबकि के बजाय

(सही) यह पाश के साथ बेहतर प्रदर्शन करती है:

यह पिंग वर्ग है।

धन्यवाद

Answer 1

loop विज्ञप्ति अन्य कार्यों के लिए धागे का उपयोग करते हुए while नहीं करता है। इसलिए, यदि आप कई कलाकारों का उपयोग कर रहे हैं, तो loop का उपयोग और अधिक कुशल बनाता है। दूसरी तरफ, while और receive का उपयोग कर एक एकल अभिनेता loop और react (या उस मामले के लिए, loop और receive) का उपयोग करके एक से अधिक तेज़ है।

Answer 2

while/receive पाश blocks a thread, जबकि loop/react निर्माण नहीं करता है। इसका मतलब है कि पहले निर्माण को प्रति अभिनेता एक थ्रेड की आवश्यकता होती है, जो जल्दी धीमा हो जाता है।

Haller and Odersky 2006 के अनुसार,

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

, (जाहिर है वे बाद में receive के व्यवहार बदल गया है और react करने के लिए पुराने receive नाम दिया।)