Akka Actor 模型云计算架构以及 Remote Actor的简单示例
作者：邵明东
Akka是一个用Scala编写的开源事件驱动中间件框架库，用于简化编写容错的、高可伸缩性的Java和Scala的Actor模型应用。用于构建高性能、高可靠以及分布式的Java和Scala应用程序，再加上Play2等web应用框架以及大数据系统很容易形成功能强大的云计算服务。Akka由TypesafeInc.发布维护，集成在反应式应用开发平台TypesafeActivator（Play2framework+Scala+Akka）中。Akka已经成功运用在银行和电信等行业，系统几乎不宕机（高可用性99.9999999%，一年只有31ms宕机）。
基于Akka的反应式应用开发是一种新型的APP开发模式，在消费者与企业环境中越来越流行，与传统的web应用和移动应用的不同如下：
1.事件驱动，很容易并行的异步的处理消息或事件。
2.可伸缩，在节点内或者跨节点弹性的按需求调度计算资源。
3.及时恢复，具有自动恢复和自动修复功能，提供不停顿的业务持续运营。
4.敏捷反应，单页富用户界面极具吸引力，即时反馈用户的交互输入与其它激励输入。
Typesafe的反应式开发平台定位于快速开发复杂用户界面，在新的抽象层执行并发和并行任务，同时运用规模预测降低风险。Akka可以部署在云计算基础设施（I）、平台（P）和软件（S）的任意一层。
为此先理解云计算的服务形式：
1.IaaS（Infrastructureas a Service），基础设施即服务。消费者通过网络（LAN，WAN或者Internet等）从完善的计算机基础设施获得服务，运算资源等，部署与执行操作系统或应用程式等各种软件。客户端无须购买服务器、软件等网络设备，即可任意部署和运行计算资源，不能管理或控制底层基础设施，但可以控制操作系统、储存装置、已部署的应用程序等，可以有限度地控制特定的网络元件，如主机端防火墙等。
2.SaaS（Softeware as aService），软件即服务。它是一种软件交付模式，云端集中托管软件和相关数据，软件仅需通过互联网，不须安装即可使用。用户通常使用精简客户端经由一个网页浏览器来访问软件即服务。SaaS已经被吸纳进所有领先的企业级软件公司的战略中，最大的卖点之一就是通过将硬件和软件维护及支持外包给SaaS的提供者，来降低IT成本。
3.PaaS（Platform as a Service），平台即服务。它是基础平台或者开发环境作为一种服务提供的商业模式，以SaaS的形式提交给用户。PaaS提供给企业定制研发的中间件平台，同时涵盖数据库和应用服务器等，提高Web平台上利用的资源数量，可以推进SaaS的发展。
事实上，云计算本身由基础设施（I）、平台（P）和软件（S）组成，I是系统基础，P是开发资源，S则是应用，如下图1所示：
因此云计算提供的服务有I，P和S的各种组合形成，IaaS，PaaS和SaaS之间的界限不是越来越模糊，而是越来越清晰，只是生产商可以提供的服务除了IaaS，PaaS和SaaS以外，还有I，P和S的组合形式I&PaaS，I&SaaS，P&SaaS和I&P&SaaS。统一起来就是XaaS，一切皆服务，“Xas a service”、“anythingas a service”或“everythingas a service”。有时XaaS被称为SPI模式（SaaS，PaaS，IaaS），其他例子还包括存储即服务（SaaS，storageas a service）、通信即服务（CaaS，communicationsas a service）、网络即服务（NaaS，networkas a service）和监测即服务（MaaS，monitoringas a service）等等。
Akka是一种运用了舆论传播协议（gossipprotocols）和自动故障检测的集群技术，运行在java虚拟机上，可以在异构系统之间部署集群运算，进一步扩展到网格计算。因此有人认为Akka是一种IaaS。同时Akka又是中间件，是PaaS的一个典型特征。Akka提供Java和Scala两套API，很容易开发应用程序，也能提供SaaS。Akka的Actor简化了多线程及其同步的操作，很容易编写云终端程序。
Actor模型由CarlHewitt在上世纪70年代早期提出，是一种分布式编程中的并行和并发计算模型。Actor是一种程序上的抽象概念，被视为并行运算的基本单元：当一个Actor接收到一条消息，它可以做出一些决策、建立子Actor、传送或转发消息、决定要如何应答消息以及如何控制交互过程等等。其特点如下：
-
系统中的所有事物都可以抽象为一个Actor，如同一个有生命特征的Class，可以继承Actor，创建子Actor，响应外部激励（stimuli）等等
-
Actor封装了状态和行为操作，Actor之间完全独立，自主
-
不能直接访问Actor的内部状态，属性和方法，必须通过消息访问
-
消息传递是非阻塞和异步的，机制是邮件消息队列
-
Actor对不同消息采取的响应动作可以是并行的
事实上Actor模型是一个具有自适应和初步智能的软件智能体（Agent）模型，Actor集群则是软件多智能体（Multi-Agent）。将Actor的功能进一步扩充可形成适用于各种业务的自主，协同和学习的分布式多智能体系统。
Akka的ActorSystem生成的Actor具有以上Actor的特点，通过Actor的context.actorOf方法可以创建子Actor。Actor的receive方法响应消息，在case分支并行执行各种动作。Akka将底层机制（如线程、锁、非阻塞IO）隐藏，业务逻辑代码在Actor对象中，用这些代码发送和接受消息，并行执行动作，而同步、负载均衡、容错与伸缩则交由Akka处理。Akka2.X改善了扩展性（每个Actor大约300Byte，每GB内存可创建数百万Actor），简化了终端（Endpoint）或数据中心环境下分布式应用程序的创建。Akka的其它特性包括：
1.位置透明。Akka使用Actor路径来实现位置透明性。一个Actor在Akka系统节点中的位置表示为
akka.
akka.tcp://[email protected]:2552/user/actorName
2.基于配置的部署，在运行时指定拓扑。配置文件默认为reference.conf，对于Akka应用程序它位于工程的classpath根目录（如/bin）。reference.conf的一个例子如下
akka{
actor{
provider= "akka.remote.RemoteActorRefProvider"
}
remote{
enabled-transports= ["akka.remote.netty.tcp"]
netty.tcp{
hostname= "192.168.0.16"
port= 5150
}
}
}
对于remoteActor的配置一般仅需修改netty.tcp中的hostname和port。
3.监督与监控，监控每一个Akka组件的错误或终止。Akka实现的是“父监管”，顶部的Actor由Akka提供，每一个子Actor都由它的父Actor监管。这种限制使得actor的树形层次有明确的形式。
4.消息路由。Actor发送的消息可以经过一个路由Actor或者软路由器转发至另一个Actor。
用一个AkkaremoteActor的例子说明开发过程。一共4个工程项目：dataType（定义的数据类型），akkaLocal（本地Actor系统，包括一个服务Actor，负责与用户Actor交互，是控制节点），akkaRemote（远程Actor系统，负责计算任务，是计算节点），akkaUser（用户APPActor，，是客户端）。开发工具为Eclipse（Winows版本，eclipse-jee-kepler-SR2-win32-x86_64.zip。Linux版本，eclipse-jee-kepler-SR2-linux-gtk-x86_64.tar.gz），Scala-IDE插件（Eclipse4.3-scala2.11.1-update-site.zip）。开发语言为scala-2.11.1（Windows和Linux版本）。Akka为2.3.4版本（Windows和Linux版本）。本地操作系统为Windows8.1中文，在本地系统用VirtualBox安装一个Kubuntu14.04，akkaLocal和akkaUser运行在Windows8.1上，akkaRemote运行在Kubuntu14.04上。
Windows系统配置如下：
处理器：InterCore i7-4702MQ [email protected]，4核
内存：8G
系统类型：64位Windows8.1
Linux系统配置如下：
处理器：VirtualBox虚拟CPU，1核
内存：2G
系统类型：64位Kubuntu14.04桌面版
网络：
300Mbps无线网，VirtualBox桥接网卡
WindowsIP：192.168.0.2，KubuntuIP：192.168.0.16
认为读者熟练使用Eclipse及其插件，Scala-2.11.1和Akka-2.3.4已安装好（Windows8.1和Kubuntu14.04），在Eclipse中新建Scala-2.11.1库（scala2.11.1，导入Scala安装目录中lib的所有包）和Akka-2.3.4库（akka_2.11-2.3.4，导入Akka安装目录中lib/akka的所有包）。如下图2所示
在Windows系统下，Eclipse中创建Scala工程dataType定义消息数据类型，在src下创建dataType包，添加Scala-2.11.1库，在dataType包中新建ScalaClass，源文件为MsgData.scala，修改代码如下：
packagedataType
classMsgData(var msg:String) {
defthis()
{
this("Message")
}
}
caseobject Start
caseclass Message(msg: String)
caseclass MessageInt(a:Int,b:Int)
objectDemo extends App {
println("Thisis a message data library package:")
println("classMsgData(var msg:String)")
println("caseobject Start")
println("caseclass Message(msg: String)")
println("caseclass MessageInt(a:Int,b:Int)")
}
这些Class和Object定义了一些消息，工程中仅使用了MessageInt，它定义了一个有两个整数运算的消息。
在工程的根目录新建MANIFEST.MF文件，代码如下：
Manifest-Version:1.0
Class-Path:scala-actors-2.11.0.jar空格
空格scala-actors-migration_2.11-1.1.0.jar空格
空格scala-compiler.jar空格
空格scala-continuations-library_2.11-1.0.2.jar空格
空格scala-continuations-plugin_2.11.1-1.0.2.jar空格
空格scala-library.jar空格
空格scala-parser-combinators_2.11-1.0.1.jar空格
空格scala-reflect.jar空格
空格scala-stm_2.11-0.7.jar空格
空格scala-swing_2.11-1.0.1.jar空格
空格scala-xml_2.11-1.0.2.jar空格
空格slf4j-api-1.7.5.jar空格
空格uncommons-maths-1.2.2a.jar空格
Main-Class:dataType.Demo
这个文件用来将Class文件打包成jar文件，注意Class-Path的XXXXX.jar前后必须有空格分隔每一个包。dataType工程MANIFEST.MF中Class-Path下是Scala-2.11.1库的包。然后使用Eclipse的打包工具，选择清单MANIFEST.MF将dataType导出为库文件datatype.jar。将库文件datatype.jar存放在一个目录（例如D:\program\scala\prjLib，本例是在Scala的安装目录下）。新建库PrjLibrary，导入D:\program\scala\prjLib\datatype.jar，如图2所示。然后这个库PrjLibrary就可以添加到另外3个工程，统一消息数据类型。dataType工程如下图3所示
在Kubuntu系统下，Eclipse中创建Scala工程akkaRemote，用于接收和执行akkaLocal发送的计算任务消息命令，在src下创建remote包，添加PrjLibrary库，Scala-2.11.1库和Akka-2.3.4库。在remote包中新建ScalaApplication，源文件为HelloRemote.scala，代码如下：
packageremote
importakka.actor._
importakka.remote._
importdataType._
classRemoteActor extends Actor {
defreceive = {
casemsg: String => {
println(s"RemoteActorreceived message '$msg'")
//sender ! "k"
}
caseMessageInt(a,b) => {
println("RemoteActor got MesageInt:"+a+"*"+b)
sender ! ( a*b)
}
case _ =>
println("RemoteActor got something unexpected.")
}
}
objectHelloRemote extends App {
valsystem = ActorSystem("HelloRemoteSystem")
valremoteActor = system.actorOf(Props[RemoteActor], name ="RemoteActor")
remoteActor! "The RemoteActor is alive"
}
receive方法接收到一个MessageInt(a,b)消息后，计算a*b，将结果回发给sender（akkaLocal中的LocalActor）。
在src目录中新建Akka的配置文件application.conf，代码如下：
akka{
//loglevel= "DEBUG"
actor{
provider= "akka.remote.RemoteActorRefProvider"
}
remote{
enabled-transports= ["akka.remote.netty.tcp"]
transport= "akka.remote.netty.NettyRemoteTransport"
//log-sent-messages= on
//log-received-messages= on
netty.tcp{
hostname= "192.168.0.16"
port= 5150
}
}
}
在工程的根目录新建MANIFEST.MF文件，代码如下：
Manifest-Version:1.0
Class-Path:lib/akka-actor_2.11-2.3.4.jar
lib/akka-agent_2.11-2.3.4.jar
lib/akka-camel_2.11-2.3.4.jar
lib/akka-cluster_2.11-2.3.4.jar
lib/akka-contrib_2.11-2.3.4.jar
lib/akka-dataflow_2.11-2.3.4.jar
lib/akka-durable-mailboxes-2.3.4.jar
lib/akka-file-mailbox_2.11-2.3.4.jar
lib/akka-kernel_2.11-2.3.4.jar
lib/lib/akka-mailboxes-common_2.11-2.3.4.jar
lib/akka-multi-node-testkit_2.11-2.3.4.jar
lib/akka-persistence-experimental_2.11-2.3.4.jar
lib/akka-remote_2.11-2.3.4.jar
lib/akka-remote-tests_2.11-2.3.4.jar
lib/akka-slf4j_2.11-2.3.4.jar
lib/akka-testkit_2.11-2.3.4.jar
lib/akka-transactor_2.11-2.3.4.jar
lib/camel-core-2.10.3.jar
lib/config-1.2.1.jar
lib/guava-12.0.jar
lib/hawtjni-runtime-1.8.jar
lib/jline-2.11.jar
lib/jsr305-1.3.9.jar
lib/leveldb-0.5.jar
lib/leveldb-api-0.5.jar
lib/leveldbjni-1.7.jar
lib/leveldbjni-all-1.7.jar
lib/leveldbjni-linux32-1.5.jar
lib/leveldbjni-linux64-1.5.jar
lib/leveldbjni-osx-1.5.jar
lib/leveldbjni-win32-1.5.jar
lib/leveldbjni-win64-1.5.jar
lib/netty-3.8.0.Final.jar
lib/protobuf-java-2.5.0.jar
lib/scala-actors-2.11.0.jar
lib/scala-actors-migration_2.11-1.1.0.jar
lib/scala-compiler.jar
lib/scala-continuations-library_2.11-1.0.2.jar
lib/scala-continuations-plugin_2.11.1-1.0.2.jar
lib/scala-library.jar
lib/scala-parser-combinators_2.11-1.0.1.jar
lib/scala-reflect.jar
lib/scala-stm_2.11-0.7.jar
lib/scala-swing_2.11-1.0.1.jar
lib/scala-xml_2.11-1.0.2.jar
lib/slf4j-api-1.7.5.jar
lib/uncommons-maths-1.2.2a.jar
lib/datatype.jar
Main-Class:remote.HelloRemote
同dataType工程中的MANIFEST.MF文件注意空格。本例将Scala和Akka的所有库文件都添加到了Class-Path中，可以只添加源程序导入包的jar文件。
akkaRemote工程如下图4所示
如果出现无法绑定到akkaRemote计算节点的错误，可以在远程计算节点主机上运行命令sudofuser -k -n tcp 5150，然后再重新运行akkaRemote。
在Windows系统下，Eclipse中创建Scala工程akkaLocal，用于接收和执行akkaUser请求的计算服务消息命令，在src下创建local包，添加PrjLibrary库，Scala-2.11.1库和Akka-2.3.4库。在local包中新建ScalaApplication，源文件为Local.scala，代码如下
packagelocal
importakka.actor._
importakka.remote._
importdataType._
objectLocal extends App {
implicitval system = ActorSystem("LocalSystem")
vallocalActor = system.actorOf(Props[LocalActor], name = "LocalActor") // the local actor
localActor! "START" // start the action
}
classLocalActor extends Actor {
//create the remote actor
valremote =context.actorSelection("akka.tcp://[email protected]:5150/user/RemoteActor")
varsvr = context.actorOf(Props[ServerActor], name = "server")
context.watch(svr)
defreceive = {
case"START" => {
println("LocalActorreceived START")
remote! "Hello from the LocalActor"
}
casemsg:String => {
//sender! "a"
println(s"LocalActorreceived message: '$msg'")
}
caseMessageInt(a,b) => {
println("Receivedtask from user:"+MessageInt(a,b).toString())
remote! MessageInt(a,b)
}
caseresultInt:Int => {
svr! resultInt
}
case_ =>
println("LocalActorgot something unexpected.")
}
}
classServerActor extends Actor {
varlocalAct =context.actorSelection("akka://LocalSystem/user/LocalActor")
varuser1 = context.actorSelection("akka://LocalSystem/user/LocalActor")
defreceive = {
case"START" => {
println("ServerActorreceived START")
}
caseMessageInt(a,b) => {
localAct !MessageInt(a,b)
user1=context.actorSelection(sender.path.toString())
println("ServerActor user1 path:"+sender.path.toString())
}
caseresultInt:Int => {
user1! resultInt
}
case_ =>
println("LocalActorgot something unexpected.")
}
}
LocalActor的receive方法接收到一个MessageInt(a,b)消息后，将消息分发给remote
（RemoteActor），remote计算a*b后将结果发回，LocalActor的receive方法接收到结果后，再将结果发给子Actorsvr（ServerActor）。ServerActor的receive方法接收到一个MessageInt(a,b)消息后，将任务发给localAct（LocalActor）执行，LocalActor将结果发回，ServerActor接收为消息resultInt，然后发送给用户user1（AppActor）。
在src目录中新建Akka的配置文件application.conf，代码如下：
akka{
//loglevel= "DEBUG"
actor{
provider= "akka.remote.RemoteActorRefProvider"
}
remote{
enabled-transports= ["akka.remote.netty.tcp"]
transport= "akka.remote.netty.NettyRemoteTransport"
//log-sent-messages= on
//log-received-messages= on
netty.tcp{
hostname= "192.168.0.2"
port= 2562
}
}
}
在工程的根目录新建MANIFEST.MF文件，代码如下（注意空格）：
Manifest-Version:1.0
Class-Path:lib/akka-actor_2.11-2.3.4.jar
lib/akka-agent_2.11-2.3.4.jar
lib/akka-camel_2.11-2.3.4.jar
lib/akka-cluster_2.11-2.3.4.jar
lib/akka-contrib_2.11-2.3.4.jar
lib/akka-dataflow_2.11-2.3.4.jar
lib/akka-durable-mailboxes-2.3.4.jar
lib/akka-file-mailbox_2.11-2.3.4.jar
lib/akka-kernel_2.11-2.3.4.jar
lib/lib/akka-mailboxes-common_2.11-2.3.4.jar
lib/akka-multi-node-testkit_2.11-2.3.4.jar
lib/akka-persistence-experimental_2.11-2.3.4.jar
lib/akka-remote_2.11-2.3.4.jar
lib/akka-remote-tests_2.11-2.3.4.jar
lib/akka-slf4j_2.11-2.3.4.jar
lib/akka-testkit_2.11-2.3.4.jar
lib/akka-transactor_2.11-2.3.4.jar
lib/camel-core-2.10.3.jar
lib/config-1.2.1.jar
lib/guava-12.0.jar
lib/hawtjni-runtime-1.8.jar
lib/jline-2.11.jar
lib/jsr305-1.3.9.jar
lib/leveldb-0.5.jar
lib/leveldb-api-0.5.jar
lib/leveldbjni-1.7.jar
lib/leveldbjni-all-1.7.jar
lib/leveldbjni-linux32-1.5.jar
lib/leveldbjni-linux64-1.5.jar
lib/leveldbjni-osx-1.5.jar
lib/leveldbjni-win32-1.5.jar
lib/leveldbjni-win64-1.5.jar
lib/netty-3.8.0.Final.jar
lib/protobuf-java-2.5.0.jar
lib/scala-actors-2.11.0.jar
lib/scala-actors-migration_2.11-1.1.0.jar
lib/scala-compiler.jar
lib/scala-continuations-library_2.11-1.0.2.jar
lib/scala-continuations-plugin_2.11.1-1.0.2.jar
lib/scala-library.jar
lib/scala-parser-combinators_2.11-1.0.1.jar
lib/scala-reflect.jar
lib/scala-stm_2.11-0.7.jar
lib/scala-swing_2.11-1.0.1.jar
lib/scala-xml_2.11-1.0.2.jar
lib/slf4j-api-1.7.5.jar
lib/uncommons-maths-1.2.2a.jar
lib/datatype.jar
Main-Class:local.Local
akkaLocal工程如下图5所示
为便于演示将akkaLocal工程的二进制文件打包成akkaLocal.jar文件，放入一个文件夹（例如jars），在该文件夹里新建lib目录将所有PrjLibrary库，Scala-2.11.1库和Akka-2.3.4库的jar文件复制进去。在Windowscmd窗口下进入akkaLocal.jar文件的目录运行java-jarakkaLocal.jar可启动服务。
在Windows系统下，Eclipse中创建Scala工程akkaUser，用作客户端向akkaLocal发送用户请求的计算服务消息执行命令，在src下创建akkauser包，添加PrjLibrary库，Scala-2.11.1库和Akka-2.3.4库。在akkauser包中新建ScalaApplication，源文件AkkaUser.scala，代码如下
packageakkauser
importakka.actor._
importakka.remote._
importdataType._
objectAkkaUser extends App {
implicitval system = ActorSystem("AppUserSystem")
valappActor = system.actorOf(Props[AppActor], name = "AppUserActor") // the local actor
appActor! "START"
}
classAppActor extends Actor {
varserver =context.actorSelection("akka.tcp://[email protected]:2562/user/LocalActor/server")
varx=0
defreceive = {
case"START" => {
println("AppActorreceived START")
server! MessageInt(1,1)
}
caserst:Int => {
println("resultfrom server:"+rst)
x+=1
if(x>10)x=0
server! MessageInt(2,x)
}
}
}
AppActor收到一个"START"启动命令后，向LocalActor的子Actorserver发送一个1*1的请求，AppActor收到1*1的结果rst后打印出结果，变量x计数（0~10），再发送一个2*x的请求，如此循环计算2*（0，1，~10）=0，2，~20。
在src目录中新建Akka的配置文件application.conf，代码如下：
akka{
//loglevel= "DEBUG"
actor{
provider= "akka.remote.RemoteActorRefProvider"
}
remote{
enabled-transports= ["akka.remote.netty.tcp"]
transport= "akka.remote.netty.NettyRemoteTransport"
//log-sent-messages= on
//log-received-messages= on
netty.tcp{
hostname= "192.168.0.2"
port= 15601
}
}
}
在工程的根目录新建MANIFEST.MF文件，代码如下（注意空格）：
Manifest-Version:1.0
Class-Path:lib/akka-actor_2.11-2.3.4.jar
lib/akka-agent_2.11-2.3.4.jar
lib/akka-camel_2.11-2.3.4.jar
lib/akka-cluster_2.11-2.3.4.jar
lib/akka-contrib_2.11-2.3.4.jar
lib/akka-dataflow_2.11-2.3.4.jar
lib/akka-durable-mailboxes-2.3.4.jar
lib/akka-file-mailbox_2.11-2.3.4.jar
lib/akka-kernel_2.11-2.3.4.jar
lib/lib/akka-mailboxes-common_2.11-2.3.4.jar
lib/akka-multi-node-testkit_2.11-2.3.4.jar
lib/akka-persistence-experimental_2.11-2.3.4.jar
lib/akka-remote_2.11-2.3.4.jar
lib/akka-remote-tests_2.11-2.3.4.jar
lib/akka-slf4j_2.11-2.3.4.jar
lib/akka-testkit_2.11-2.3.4.jar
lib/akka-transactor_2.11-2.3.4.jar
lib/camel-core-2.10.3.jar
lib/config-1.2.1.jar
lib/guava-12.0.jar
lib/hawtjni-runtime-1.8.jar
lib/jline-2.11.jar
lib/jsr305-1.3.9.jar
lib/leveldb-0.5.jar
lib/leveldb-api-0.5.jar
lib/leveldbjni-1.7.jar
lib/leveldbjni-all-1.7.jar
lib/leveldbjni-linux32-1.5.jar
lib/leveldbjni-linux64-1.5.jar
lib/leveldbjni-osx-1.5.jar
lib/leveldbjni-win32-1.5.jar
lib/leveldbjni-win64-1.5.jar
lib/netty-3.8.0.Final.jar
lib/protobuf-java-2.5.0.jar
lib/scala-actors-2.11.0.jar
lib/scala-actors-migration_2.11-1.1.0.jar
lib/scala-compiler.jar
lib/scala-continuations-library_2.11-1.0.2.jar
lib/scala-continuations-plugin_2.11.1-1.0.2.jar
lib/scala-library.jar
lib/scala-parser-combinators_2.11-1.0.1.jar
lib/scala-reflect.jar
lib/scala-stm_2.11-0.7.jar
lib/scala-swing_2.11-1.0.1.jar
lib/scala-xml_2.11-1.0.2.jar
lib/slf4j-api-1.7.5.jar
lib/uncommons-maths-1.2.2a.jar
lib/datatype.jar
Main-Class:akkauser.AkkaUser
akkaUser工程如下图6所示
所有工程已创建好，可以开始运行，首先在Kubuntu下的Eclipse中runakkaRemote，然后在Windows的cmd中运行akkaLocal.jar，最后在Windows下的Eclipse中runakkaUser。akkaRemote的运行如下图7所示
akkaLocal.jar的运行如下图8所示
akkaUser的运行如下图9所示
此时的Windows系统网络资源如下图10所示
Windows系统CPU资源如下图11所示
Kubuntu系统资源如下图12所示
以上是在计算一个乘法操作情况下的系统资源，占用的网络带宽在500~600Kps，如果计算一个加法操作占用的网络带宽在1.5~1.6Mps，如果仅发送一个字节的字符串占用的网络带宽在6Mps左右。
本例仅仅使用了Akka的远程Actor就可以构建一个简单的云计算模型，具有本地服务节点，远程计算节点和客户端的功能，如果再运用Akka的集群管理功能和Play2web框架就可以构建功能强大的云计算应用。