एक उदाहरण के रूप में अक्का 2.0 का उपयोग करते हुए टाइपसेक स्टैक 2.0 की समीक्षा और अभिनेता मॉडल से परिचय

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

अभिनेता मॉडल

अभिनेता मॉडल की एक कठोर परिभाषा, साथ ही इसके इतिहास और मौलिक अवधारणाओं को विकिपीडिया पर पाया जा सकता है। संक्षेप में, अभिनेता मॉडल दर्शन पर आधारित है कि चारों ओर सब कुछ एक अभिनेता है। यह ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के दर्शन के समान है, एकमात्र अंतर यह है कि अभिनेता मॉडल में, गणना अनिवार्य रूप से समय में मेल खाती है, जब, ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में, एक नियम के रूप में, कार्यक्रमों को क्रमिक रूप से निष्पादित किया जाता है। अभिनेता मॉडल में कोई साझा राज्य नहीं है, और डेटा का आदान-प्रदान एक तंत्र से दूसरे अभिनेता के लिए संदेश भेजने वाले तंत्र का उपयोग करके किया जाता है। प्रत्येक अभिनेता के पास आने वाले संदेशों की कतार होती है, जो उसके द्वारा क्रमिक रूप से संसाधित होते हैं। एक साझा राज्य की अनुपस्थिति और संदेशों की अनुक्रमिक प्रसंस्करण के कारण, अभिनेता मॉडल पर आधारित कार्यक्रमों में गणना का समानांतरीकरण बहुत सरल हो जाता है, और ऐसे कार्यक्रमों की विश्वसनीयता बढ़ जाती है।

अक्का

जैसा कि ऊपर लिखा गया है, अक्का जेवीएम पर एक अभिनेता मॉडल को लागू करता है। अभिनेताओं को अन्यथा हल्के धागे (हरे रंग के धागे) कहा जाता है। इस तरह के प्रवाह वास्तव में हल्के होते हैं, उनकी संख्या ~ 2.7 मिलियन प्रति 1 जीबी रैम तक पहुंच सकती है, और प्रेषित संदेशों की संख्या एक नोड पर 20 मिलियन / सेकंड से अधिक है। नेटवर्क के माध्यम से अभिनेताओं की बातचीत को व्यवस्थित करने की संभावना है, जो विकसित एप्लिकेशन की लगभग असीमित मापनीयता प्रदान करता है। अक्का की क्षमताओं के बारे में अधिक जानकारी आधिकारिक वेबसाइट पर देखी जा सकती है।

टाइपसेफ और अक्का उदाहरण

मूल: यहाँ

टाइपकाफ़ स्टैक के साथ अक्का के साथ शुरुआत करना बहुत आसान है। स्टैक वितरण को डाउनलोड करने और इसे स्थापित करने के लिए सेटअप प्रक्रिया नीचे आती है । यद्यपि आप विकास के लिए जावा और स्काला दोनों का उपयोग कर सकते हैं, बाद का उपयोग करके कार्यक्रम विशेष रूप से पतला और पढ़ने और समझने में आसान बनाता है, इसलिए हम नीचे दिए गए उदाहरण में स्काला का उपयोग करेंगे।

समस्या का बयान

इस उदाहरण में, हम PI की संख्या के मूल्य की गणना करने के लिए अभिनेताओं का उपयोग करते हैं। यह ऑपरेशन प्रोसेसर का गहनता से उपयोग करता है, इसलिए अक्का आपको मल्टी-कोर मशीन पर स्केलेबल, समानांतर कंप्यूटिंग को लागू करने की अनुमति देगा। इस्तेमाल किया एल्गोरिथ्म अच्छी तरह से समानांतर है। प्रत्येक गणना स्वतंत्र है, जो अभिनेता मॉडल पर पूरी तरह से अनुमानित है। गणना के लिए सूत्र निम्नानुसार है:



मुख्य अभिनेता इस श्रृंखला को घटकों में विभाजित करेगा और प्रत्येक सदस्य को सहायक अभिनेता (श्रृंखला के प्रत्येक सदस्य के लिए एक सहायक अभिनेता) की गणना के लिए भेजेगा। गणना के पूरा होने पर, प्रत्येक सहायक अभिनेता मुख्य अभिनेता को परिणाम लौटाएगा। सभी गणनाओं के परिणाम प्राप्त करने के बाद, मुख्य अभिनेता जवाब तैयार करेगा।

परियोजना निर्माण

सबसे पहले, आपको giter8 टेम्पलेट से एक प्रोजेक्ट बनाने की आवश्यकता है (टाइपसेक स्टैक स्थापित होना चाहिए):
c:\temp>g8 typesafehub/akka-scala-sbt

Akka 2.0 Project Using Scala and sbt

organization [org.example]: akka.tutorial
package [org.example]: akka.tutorial.first.scala
name [Akka Project In Scala]: PI Calculator
akka_version [2.0]:
version [0.1-SNAPSHOT]:

Applied typesafehub/akka-scala-sbt.g8 in pi-calculator

अब जब प्रोजेक्ट बना है, तो प्रोजेक्ट फ़ोल्डर पर जाएँ:
c:\temp>cd pi-calculator


कोड लिखना शुरू करें

सबसे पहले, आपको उपयुक्त फ़ोल्डर में ./src/main/scala/akka/tutorial/first/scala/ फ़ाइल बनाने की आवश्यकता है ( ./src/main/scala/akka/tutorial/first/scala/ ) और आवश्यक लाइब्रेरी आयात करें:
import akka.actor._
import akka.routing.RoundRobinRouter
import akka.util.Duration
import akka.util.duration._


संदेश टेम्पलेट बनाना

हम ऊपर वर्णित हमारे आवेदन की वास्तुकला को स्पष्ट करते हैं। एक Master अभिनेता है जो कई Worker अभिनेता बनाता है और गणना को आरंभ करता है। ऐसा करने के लिए, वह पूरे कार्य को छोटे कार्यों में विभाजित करता है और इन कार्यों को अभिनेताओं के Worker को भेजता है। ऑपरेशन करने के बाद, Worker एक्टर एकत्रीकरण के लिए परिणाम लौटाते हैं। गणना पूरी होने के बाद, Master अभिनेता अभिनेता को Listener परिणाम भेजता है, जो इसे स्क्रीन पर प्रदर्शित करता है।

इस विवरण के आधार पर, हम उन संदेशों को बनाएंगे जो सिस्टम में प्रेषित किए जाएंगे:

• Calculate - गणना शुरू करने के लिए Master अभिनेता को भेजा जाता है
• Work - Master Worker अभिनेता को अभिनेताओं Master भेजा जाता है, जिसमें किए जाने वाले ऑपरेशन के विवरण होते हैं
• Result - Worker द्वारा अभिनेता से Master अभिनेता द्वारा भेजा गया
• PiApproximation - Master अभिनेता द्वारा Listener अभिनेता को भेजा गया, इसमें गणना का समय और गणना करने के लिए लिया गया समय शामिल है

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

 सीलबंद विशेषता PiMessage
 केस ऑब्जेक्ट की गणना पाईमैसेज को बढ़ाती है
 केस क्लास वर्क (शुरू: इंट, एनआरओफ़ेहल्ट्स: इंट) पीमैसेज का विस्तार करता है
 केस क्लास रिजल्ट (मान: डबल) का विस्तार PiMessage है
 मामला कक्षा PiApproximation (pi: डबल, अवधि: अवधि)

Worker एक्टर बनाना

अब हम एक Worker एक्टर बना सकते हैं। यह Actor गुण में मिश्रण और एक receive विधि को परिभाषित करने के द्वारा किया जाता है। यह तरीका एक इनकमिंग मैसेज हैंडलर है:

 क्लास वर्कर ने निकाला एक्टर {

   // कैल्क्युलेटर

   पराजय = {
     मामला कार्य (प्रारंभ, nrOfElements) ⇒
       इस!  परिणाम (गणनापाइफ़ोर (शुरू, nrOfElements)) // काम करते हैं
   }
 }

जैसा कि आप देख सकते हैं, हमने Work मैसेज हैंडलर को जोड़ा है, जो कि calculatePiFor ऑपरेशन पूरा होने के बाद Result रिस्पांस मैसेज बनाता है और इसे वापस भेजने वाले को भेज देता है। अब हम calculatePiFor लागू करते calculatePiFor :

 डीईएफ़ की गणना करें (शुरू करें: Int, nrOfElements: Int): डबल = {
   var acc = 0.0
   के लिए (मैं (शुरू तक (शुरू + nrOfElements))
     acc + = 4.0 * (1 - (i% 2) * 2) / (2 * i + 1)
   एसीसी
 }

एक Master एक्टर बनाना

Master अभिनेता थोड़ा अधिक जटिल है, क्योंकि उनके निर्माण में, Worker अभिनेताओं के बीच संचालन के वितरण को सुविधाजनक बनाने के लिए एक चक्रीय राउटर बनाया गया है:

 वैल वर्कर राउटर = संदर्भ.ऐक्टॉरऑफ (
   प्रॉप्स [वर्कर] .withRouter (RoundRobinRouter (nrOfWorkers)), नाम = "वर्कर राउटर")

अब हम खुद Master एक्टर लिखते हैं। यह अभिनेता निम्नलिखित मापदंडों के साथ बनाया गया है:

• nrOfWorkers - Worker एक्टर्स की संख्या
• nrOfMessages - संचालन की श्रृंखला की कुल संख्या
• nrOfElements - प्रत्येक Worker अभिनेता द्वारा गणना की गई एक श्रृंखला में संचालन की संख्या

तो हमारे पास निम्नलिखित कोड हैं:

 कक्षा मास्टर (nrOfWorkers: Int, 
   nrOfMessages: इंट, 
   nrOfElements: Int, 
   श्रोता: अभिनेता (अभिनेता) {

   var pi: डबल = _
   var nrOfResults: Int = _
   वैल शुरू: लंबी = System.currentTimeMillis

   वैल वर्कर राउटर = संदर्भ.ऐक्टॉरऑफ (
     प्रॉप्स [वर्कर] .withRouter (RoundRobinRouter (nrOfWorkers)), नाम = "वर्कर राउटर")

   पराजय = {
     // संदेशों को संभालें ...
   }

 }

ऊपर वर्णित मापदंडों के अलावा, ActorRef ऑब्जेक्ट, जो कि Listener अभिनेता का एक संदर्भ है, Master अभिनेता को दिया जाता है। यह ध्यान दिया जाना चाहिए कि अभिनेताओं के बीच संदेशों का हस्तांतरण हमेशा ऐसे लिंक के माध्यम से किया जाता है।

लेकिन यह सब नहीं है, क्योंकि हमने संदेश संचालकों को लागू नहीं किया, जिसे अब हम लिखेंगे:

 पराजय = {
   मामले की गणना ⇒
     के लिए (i (0 तक nrOfMessages) 
       workerRouter!  काम (i * nrOfElements, nrOfElements)
   मामला परिणाम (मान) ⇒
     pi + = मान
     nrOfResults + = 1
     अगर (nrOfResults == nrOfMessages) {
       // परिणाम श्रोता को भेजें
       श्रोता!  पाइप्रोसेप्शन (पीआई, अवधि = (System.currentTimeMillis - start) .millis
       // इस अभिनेता और इसके सभी पर्यवेक्षणीय बच्चों को रोक देता है
       संदर्भ। स्टॉप (स्व)
     }
 }

सामान्य तौर पर, कोड स्पष्ट होना चाहिए, यह केवल ध्यान दिया जाना चाहिए कि गणना पूरी होने के बाद और परिणाम मुद्रित होने के बाद, Master अभिनेता को context.stop(self) साथ बंद कर दिया जाता है। context.stop(self) कमांड।

एक Listener अभिनेता बनाना

इस अभिनेता का कार्यान्वयन काफी सरल है। यह Master अभिनेता से एक PiApproximation संदेश प्राप्त करता है, परिणाम प्रिंट करता है, और अभिनेता प्रणाली को रोकता है:

 वर्ग श्रोता अभिनेता {
   पराजय = {
     मामला पाइप्रोसेप्शन (pi, अवधि) ⇒
       Println ("\ n \ tPi सन्निकटन: \ t \ t% s \ n \ t समाप्‍त समय: \"% s "
         .फॉर्मैट (पीआई, अवधि))
       संदर्भ। system.shutdown ()
   }
 }

एप्लिकेशन ऑब्जेक्ट लिखना

अब यह केवल एप्लिकेशन ऑब्जेक्ट लिखने के लिए बना हुआ है और हमारा कार्यक्रम तैयार है:

 ऑब्जेक्ट पाई ऐप {

   गणना (nrOfWorkers = 4, nrOfElements = 10000, nrOfMessages = 10000)

   // अभिनेता और संदेश ...

   def गणना (nrOfWorkers: Int, nrOfElements: Int, nrOfMessages: इंट {
     // एक अका सिस्टम बनाएं
     वैल सिस्टम = अभिनेता प्रणाली ("पीआईएस सिस्टम")

     // परिणाम श्रोता बनाएं, जो परिणाम को प्रिंट करेगा और 
     // सिस्टम को बंद करें
     वैल श्रोता = system.actorOf (Props [श्रोता], नाम = "श्रोता")

     // मास्टर बनाएँ
     वैल मास्टर = system.actorOf (प्रॉप्स (नए मास्टर)
       nrOfWorkers, nrOfMessages, nrOfElements, listener)),
       नाम = "मास्टर")

     // गणना शुरू करें
     गुरु!  गणना

   }
 }

एप्लिकेशन लॉन्च

Sbt से एप्लिकेशन को चलाने का सबसे आसान तरीका। ऐसा करने के लिए, एप्लिकेशन के साथ फ़ोल्डर पर जाएं और sbt कमांड टाइप करें। तब हम कमांड के निम्नलिखित अनुक्रम को निष्पादित करते हैं:
c:\temp\pi-calculator>sbt
[info] Loading project definition from C:\temp\pi-calculator\project
[info] Set current project to PI Calculator (in build file:/C:/temp/pi-calculator/)
> compile
[success] Total time: 0 s, completed 20.03.2012 16:33:03

> run
[info] Running akka.tutorial.first.scala.Pi

Pi approximation: 3.1415926435897883
Calculation time: 423 milliseconds
[success] Total time: 1 s, completed 20.03.2012 16:33:25

यदि आप अभिनेताओं की संख्या 1 तक कम कर देते हैं, तो परिणाम बदल जाएगा:
> run
[info] Running akka.tutorial.first.scala.Pi

Pi approximation: 3.1415926435897883
Calculation time: 1160 milliseconds
[success] Total time: 2 s, completed 20.03.2012 16:35:16

यदि आप 8 तक बढ़ जाते हैं, तो परिणाम इस प्रकार होगा:
> run
[info] Running akka.tutorial.first.scala.Pi

Pi approximation: 3.1415926435897905
Calculation time: 388 milliseconds
[success] Total time: 1 s, completed 20.03.2012 16:36:55

परिणाम अनुमानित है, यह देखते हुए कि परीक्षण 4-परमाणु मशीन पर किए गए थे। तो अभिनेताओं की संख्या में 16 की वृद्धि लगभग कोई प्रदर्शन लाभ नहीं देती है:
> run
[info] Running akka.tutorial.first.scala.Pi

Pi approximation: 3.141592643589789
Calculation time: 372 milliseconds
[success] Total time: 1 s, completed 20.03.2012 16:40:04

Play 2.0 के बारे में एक पोस्ट जल्द ही आ रही है। सौभाग्य है