Akka学习笔记02--PI值计算，采用多核处理器并行计算

我们所使用的算法叫“embarrassingly parallel” 意思是每个子任务是独立完成的，与其它子任务无关。这个算法可以高度并行化，所以非常适合使用actor模型。

以下是我们所使用的算法的公式：

在这个特定的算法中，有一个主actor将序列分割成段并发送给工作actor来进行计算。当工作actor完成自己的序列段的计算后将结果传给主actor，由主actor进行汇总。

我们要做的设计是由一个 主 actor来启动整个计算过程，创建一组工作 actor. 整个工作会被分割成具体的小段, 各小段会以round-robin的方式发送到不同的工作 actor. 主actor等待所有的工作actor完全各自的工作并将其回送的结果进行汇总。当计算完成以后，主actor将结果发送给监听器 acotr, 由它来输出结果。

在这个基础上, 现在让我们创建在这个系统中流动的消息。我们需要4种不同的消息：

• Calculate – 发送给 主 actor 来启动计算。
• Work – 从 主 actor 发送给各 工作 actor，包含工作分配的内容。
• Result – 从 工作 actors 发送给 主 actor，包含工作actor的计算结果。
• PiApproximation – 从主 actor发送给监听器 actor，包含pi的最终计算结果和整个计算耗费的时间。

发送给actor的消息应该永远是不可变的，以避免共享可变状态。 在scala里我们有 ‘case classes’ 来构造完美的消息。现在让我们用case class创建3种消息。我们还为消息们创建一个通用的基础trait(定义为sealed以防止在我们不可控的地方创建消息)。

这里默认nrOfWorkers：4，nrOfMessages：10000，nrOfElements：10000

• nrOfWorkers – 定义我们会启动多少工作actor
• nrOfMessages – 定义会有多少整数段发送给工作actor
• nrOfElements – 定义发送给工作actor的每个整数段的大小

代码示例：

1. import akka.actor._  
2. import scala.concurrent.duration._  
3. import akka.routing.RoundRobinRouter  
4.   
5. sealed trait PiMessage  
6. case object Calculate extends PiMessage  
7. case class Work(start: Int, nrOfElements: Int) extends PiMessage  
8. case class Result(value: Double) extends PiMessage  
9. case class PiApproximation(pi: Double, duration: Duration)  
10.   
11. object PI extends App {  
12.   calculate(nrOfWorkers = 4, nrOfElements = 10000, nrOfMessages = 10000)  
13.   
14.   def calculate(nrOfWorkers: Int, nrOfElements: Int, nrOfMessages: Int) {  
15.     val system = ActorSystem("PiSystem")  
16.     val listener = system.actorOf(Props[Listener], name = "listener")  
17.     val master = system.actorOf(Props(new Master(  
18.       nrOfWorkers, nrOfMessages, nrOfElements, listener)),  
19.       name = "master")  
20.   
21.     master ! Calculate  
22.   }  
23. }  
24.   
25.   //计算PI值  
26.   class Worker extends Actor {  
27.     def calculatePiFor(start: Int, nrOfElements: Int): Double = {  
28.       var acc = 0.0  
29.       for (i ← start until (start + nrOfElements))  
30.         acc += 4.0 * (1 - (i % 2) * 2) / (2 * i + 1)  
31.       acc  
32.     }  
33.   
34.     def receive = {  
35.       case Work(start, nrOfElements) ⇒  
36.         sender ! Result(calculatePiFor(start, nrOfElements)) // perform the work  
37.     }  
38.   }  
39.   
40.   //主Actor  
41.   class Master(nrOfWorkers: Int, nrOfMessages: Int, nrOfElements: Int, listener: ActorRef)  
42.     extends Actor {  
43.     var pi: Double = _  
44.     var nrOfResults: Int = _  
45.     val start: Long = System.currentTimeMillis  
46.     //设置nrOfWorkers个Workder计算PI值  
47.     val workerRouter = context.actorOf(  
48.       Props[Worker].withRouter(RoundRobinRouter(nrOfWorkers)), name = "workerRouter")  
49.   
50.     def receive = {  
51.       case Calculate ⇒  
52.         for (i ← 0 until nrOfMessages) workerRouter ! Work(i * nrOfElements, nrOfElements)  
53.       case Result(value) ⇒  
54.         pi += value  
55.         nrOfResults += 1  
56.         if (nrOfResults == nrOfMessages) {  
57.           listener ! PiApproximation(pi, duration = (System.currentTimeMillis - start).millis)  
58.           context.stop(self)  
59.         }  
60.     }  
61.   }  
62.   
63.   //监听作用的Actor，记录打印  
64.   class Listener extends Actor {  
65.     def receive = {  
66.       case PiApproximation(pi, duration) ⇒  
67.         println("\n\tPi approximation: \t\t%s\n\tCalculation time: \t%s"  
68.           .format(pi, duration))  
69.         context.system.shutdown()  
70.     }  
71.   }  

tips: 参考于官方文档。亦有2.0的中文文档：http://www.gtan.com/akka_doc/intro/getting-started-first-scala.html。