akka简单示例-2

手动敲了一遍计算pi的示例：http://www.gtan.com/akka_doc/intro/getting-started-first-scala.html

有个笔误，花了半个小时定位。

[Torstani@sparkb5-i ~/akka_example/pi]$ cat src/Pi.scala
package akka.tutorial.first.scala
import akka.actor._
import akka.routing.RoundRobinRouter
import scala.concurrent.duration._

object Pi extends App{
        calculate(nrOfWorkers=4, nrOfElements=1000, nrOfMessages=10000)
        sealed trait PiMessage
        case object Calculate extends PiMessage
        case class Work(stat:Int, nrOfElements: Int) extends PiMessage
        case class Result(value: Double) extends PiMessage
        case class PiApproximation(pi: Double, duration: Duration)

        class Worker extends Actor{
                def calculatePiFor(start: Int, nrOfElements: Int):Double = {
                        var acc = 0.0
                        for(i<- start until (start + nrOfElements))
                                acc += 4.0 * (1 - (i%2) * 2) / (2 * i + 1)
                        acc
                }
                def receive = {
                        case Work(start, nrOfElements) =>
                                //println("worker received "+start + ":"+nrOfElements)
                                val res = calculatePiFor(start, nrOfElements)
                                sender ! Result(res)
                                //println("worker send result: "+res)
                }
        }

        class Master(nrOfWorkers:Int, nrOfMessages:Int, nrOfElements: Int, listener: ActorRef) extends Actor {
                var pi:Double = _
                var nrOfResults:Int= _
                val start:Long = System.currentTimeMillis

                val workerRouter = context.actorOf(
                        Props[Worker].withRouter(RoundRobinRouter(nrOfWorkers)), name="workerRouter")
                def receive = {
                        case Calculate =>
                                //println("master receive Calculate")
                                for(i <- 0 until nrOfMessages) 
                                        workerRouter ! Work(i*nrOfElements, nrOfElements)
                        case Result(value) =>
                                //println("master recieve result: "+value)
                                pi += value
                                nrOfResults += 1
                                if(nrOfResults == nrOfMessages){
                                        listener ! PiApproximation(pi, duration=(System.currentTimeMillis - start).millis)
                                        context.stop(self)
                                }
                }
        }
        class Listener extends Actor{
                def receive = {
                        case PiApproximation(pi, duration) =>
                                println("	pi approximation: 		%s
	Calculation time: 	%s".format(pi, duration))
                        context.system.shutdown()
                }
        }
        def calculate(nrOfWorkers:Int, nrOfElements:Int, nrOfMessages:Int) = {
                val system = ActorSystem("PiSystem")
                val listener = system.actorOf(Props[Listener], name="listener")
                val master = system.actorOf(Props(new Master(nrOfWorkers, nrOfMessages, nrOfElements, listener)), name="master")
                master ! Calculate
        }
}

[Torstan@sparkb5-i ~/akka_example/pi]$ cat Makefile 
SRC_DIR := src
SRC := $(shell find ${SRC_DIR} -name "*.scala")
DIR=remote

TARGET := HelloRemote.jar

SCALAC := scalac 
SCFLAGS := /usr/local/scala-2.10.4/lib/akka-actors.jar  

.PHONY: all clean

all: ${TARGET}

${TARGET}: ${SRC}
        ${SCALAC} -cp ${SCFLAGS} $^

clean:
        ${RM} -r ${TARGET} ${DIR}

[Torstan@sparkb5-i ~/akka_example/pi]$ cat run.sh 
#!/bin/bash

AKKA_LIB_PATH="/usr/local/akka-2.1.4/lib/akka/"

java -cp 
 .:/usr/local/scala-2.10.4/lib/scala-library.jar:/usr/local/scala-2.10.4/lib/akka-actors.jar:/usr/local/scala-2.10.4/lib/typesafe-config.jar:${AKKA_LIB_PATH}/akka-remote_2.10-2.1.4.jar:${AKKA_LIB_PATH}/protobuf-java-2.4.1.jar:${AKKA_LIB_PATH}/netty-3.5.8.Final.jar 
akka.tutorial.first.scala.Pi

执行结果：

[Torstan@sparkb5-i ~/akka_example/pi]$ ./run.sh
pi approximation: 3.1415925535897866
Calculation time: 383 milliseconds