JActor 4.2.0 RC1 发布，Actor 模式的 Java 实现（actor模型 java）

25-04-16 2

以上就是给各位分享JActor4.2.0RC1发布，Actor模式的Java实现，其中也会对actor模型java进行解释，同时本文还将给你拓展Akka2.4RC1发布，Actor开发模型库、Akka

以上就是给各位分享JActor 4.2.0 RC1 发布，Actor 模式的 Java 实现，其中也会对actor模型 java进行解释，同时本文还将给你拓展Akka 2.4 RC1 发布，Actor 开发模型库、Akka 2.5.0-RC1 发布，Actor 模型开发库、Akka Actor 模型云计算架构以及 Remote Actor 的简单示例、Akka v2.4.10_2.12.0-RC1，Actor 模型开发库等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

JActor 4.2.0 RC1 发布，Actor 模式的 Java 实现（actor模型 java）
Akka 2.4 RC1 发布，Actor 开发模型库
Akka 2.5.0-RC1 发布，Actor 模型开发库
Akka Actor 模型云计算架构以及 Remote Actor 的简单示例
Akka v2.4.10_2.12.0-RC1，Actor 模型开发库

JActor 4.2.0 RC1 发布，Actor 模式的 Java 实现（actor模型 java）

JActor 4.2.0 RC1 发布，增加对降级 actors (无 mailbox 的 actors) 的支持，用于单线程和线程安全的应用程序。

JActor 是一个 Java 的 Actor 模式的实现，经过测试在 i5 CPU 上可支持每秒钟发送超过亿条消息，可能是目前最快的。这相当于是 Scala 的 Actor 的纯 Java 版本。

示例代码：

JAMailboxFactory mailboxFactory = JAMailboxFactory.newMailboxFactory(1);
try {
    Mailbox mailbox = mailboxFactory.createMailbox();
    JCActor a = new JCActor(mailbox);
    (new Include(Greeter.class)).call(a);
    JAFuture future = new JAFuture();
    String greeting = (new Hi()).send(future, a);
    System.out.println(greeting);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    mailboxFactory.close();
}

Akka 2.4 RC1 发布，Actor 开发模型库

Akka 2.4 RC1 发布，相比最后一个 M 版本，主要改进如下：

Persistence Query types for LevelDB
protobuf serialization for Cluster Sharding, Cluster Client and Cluster Singleton
possibility to use Distributed Data module as storage for the state of the sharding coordinator instead of using Akka Persistence, contribution by Evgeniy Ostapenko
improvements of the ReceivePipeline, contribution by jeremystone

Akka 2.4.0 主要改进如下：

we dropped support for Java 6 & 7 as announced in the last roadmap update, and now require Java 8 or later
we dropped support for Scala 2.10, kept 2.11 and added 2.12 (which is at milestone 2 currently); this is in keeping with our policy to support the Scala version that is “current” when the first milestone comes out plus any later version that is published during this series’ lifetime
Akka Persistence was promoted to a fully supported module (not experimental)
added experimental stream based API for the Query Side of Akka Persistence (implementations must be provided by query plugins corresponding to the journal plugins for the various data stores)
improved support for Akka Persistence event migrations by Serializer with String Manifest and Event Adapters and prepared comprehensive documentation of strategies for schema evolution of persistent events
made Akka Persistence failure handling more robust and support rejections of events
Akka Persistence can now use multiple different Journals within one ActorSystem (thanks to Andrei Pozolotin, who also split out ClusterMetrics into their own module)
introduced Persistent FSM, thanks to an awesome contribution from leonidb
simplified setting up Akka Clusters behind NAT (including inside Docker containers)
we added the experimental Akka Typed module previously codenamed Project Gålbma, a new way of formulating Actor interactions with full type-system support
we promoted the ClusterSingleton, ClusterClient, DistributedPubSub and ClusterSharding patterns to fully a supported Cluster Tools module, including various API and configuration improvements
ClusterSharding also learnt a few new tricks (graceful shutdown, asynchronous shard allocation, reviving entries after migration thanks to Dominic Black, and more flexible use of roles [thanks to Richard Marscher)
use custom failure detection in ClusterClient to avoid quarantining in case of transient network failures
added experimental Akka Distributed Data which was previously known as Akka Data Replication (see akka-data-replication migration guide), the Distributed Data module is useful for sharing eventually consistent data (CRDTs) between nodes in an Akka Cluster
the SLF4J logging adapter can now apply the log filtering rules prior to sending to the EventStream, see the migration guidebut the biggest feature is probably that Akka 2.4 will be binary backwards compatible with Akka 2.3, see the detailed description below.

下载：https://github.com/akka/akka/archive/v2.4.0-RC1.zip。

Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。

Actor模型并非什么新鲜事物，它由Carl Hewitt于上世纪70年代早期提出，目的是为了解决分布式编程中一系列的编程问题。其特点如下：

系统中的所有事物都可以扮演一个Actor
Actor之间完全独立
在收到消息时Actor所采取的所有动作都是并行的，在一个方法中的动作没有明确的顺序
Actor由标识和当前行为描述
Actor可能被分成原始（primitive）和非原始（non primitive）类别
非原始Actor有

由一个邮件地址表示的标识
当前行为由一组知识（acquaintances）（实例变量或本地状态）和定义Actor在收到消息时将采取的动作组成

消息传递是非阻塞和异步的，其机制是邮件队列（mail-queue）
所有消息发送都是并行的

Akka 2.5.0-RC1 发布，Actor 模型开发库

Akka 2.5.0-RC1 发布了。自从 Akka 2.4.0（18 个月前）发布以来，我们已经为 2.4.x 版本系列增加了许多新功能，包括 Akka Streams 和 HTTP。但像以前一样，总会有一些变更不能在补丁版本中实现，因此 Akka 2.5 诞生了。其中的一个变化是将一些实验模块推广到完全稳定的模块，并在宣布它们稳定之前加入一些 API 改进。

2.5.0-RC1 版本的主要特性：

The Java API for AbstractActor was promoted to fully stable API. While doing this we made some small, yet important, improvements to the API that will require some mechanical changes of your source code.Thanks to @ortigali for help.
Faster and more flexible Akka Streams materializer, which matters for short lived streams, such as HTTP requests.
Distributed Data was promoted to a fully stable module. Several improvements were also included, such as:

Support for delta-CRDTs in Distributed Data to reduce the amount of data that is replicated, thanks to help from @gosubpl.
Generic type for the key in Distributed Data ORMap, thanks to @jgordijn

Coordinated shutdown to facilitate ordered stopping of actors and services and perform registered tasks during the shutdown process. This greatly simplifies tasks involved in graceful leaving of Akka Cluster.
Support remembering entities in Cluster Sharding with the Distributed Data (ddata) mode. ddata is now also the default mode for Cluster Sharding.
New Java API for Testkit taking advantage of lambas, thanks to @Hawstein
Fix performance regression for Scala 2.12, due to change in scheduling fairness of the JDK8 ForkJoinPool implementation
We added @ApiMayChange and other annotations which can be used to mark experimental API inside stable modules, primarily for use in Akka HTTP. API improvements of Akka Typed, including Java API

发布主页

下载地址

Source code (zip)
Source code (tar.gz)

Akka Actor 模型云计算架构以及 Remote Actor 的简单示例

作者：邵明东

Akka 是一个用 Scala 编写的开源事件驱动中间件框架库，用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。用于构建高性能、高可靠以及分布式的 Java 和 Scala 应用程序，再加上 Play2 等 web 应用框架以及大数据系统很容易形成功能强大的云计算服务。Akka 由 Typesafe Inc. 发布维护，集成在反应式应用开发平台 Typesafe Activator（Play2 framework+Scala+Akka）中。Akka 已经成功运用在银行和电信等行业，系统几乎不宕机（高可用性 99.9999999 %，一年只有 31ms 宕机）。

基于 Akka 的反应式应用开发是一种新型的 APP 开发模式，在消费者与企业环境中越来越流行，与传统的 web 应用和移动应用的不同如下：

1. 事件驱动，很容易并行的异步的处理消息或事件。

2. 可伸缩，在节点内或者跨节点弹性的按需求调度计算资源。

3. 及时恢复，具有自动恢复和自动修复功能，提供不停顿的业务持续运营。

4. 敏捷反应，单页富用户界面极具吸引力，即时反馈用户的交互输入与其它激励输入。

Typesafe 的反应式开发平台定位于快速开发复杂用户界面，在新的抽象层执行并发和并行任务，同时运用规模预测降低风险。Akka 可以部署在云计算基础设施（I）、平台（P）和软件（S）的任意一层。

为此先理解云计算的服务形式：

1. IaaS（Infrastructure as a Service），基础设施即服务。消费者通过网络（LAN，WAN 或者 Internet 等）从完善的计算机基础设施获得服务，运算资源等，部署与执行操作系统或应用程式等各种软件。客户端无须购买服务器、软件等网络设备，即可任意部署和运行计算资源，不能管理或控制底层基础设施，但可以控制操作系统、储存装置、已部署的应用程序等，可以有限度地控制特定的网络元件，如主机端防火墙等。

2. SaaS（Softeware as a Service），软件即服务。它是一种软件交付模式，云端集中托管软件和相关数据，软件仅需通过互联网，不须安装即可使用。用户通常使用精简客户端经由一个网页浏览器来访问软件即服务。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，一切皆服务，“X as a service”、“anything as a service” 或 “everything as a service” 。有时 XaaS 被称为 SPI 模式（SaaS，PaaS，IaaS），其他例子还包括存储即服务（SaaS，storage as a service）、通信即服务（CaaS，communications as a service）、网络即服务（NaaS，network as a service）和监测即服务（MaaS，monitoring as a service）等等。

Akka 是一种运用了舆论传播协议（gossip protocols）和自动故障检测的集群技术，运行在 java 虚拟机上，可以在异构系统之间部署集群运算，进一步扩展到网格计算。因此有人认为 Akka 是一种 IaaS。同时 Akka 又是中间件，是 PaaS 的一个典型特征。Akka 提供 Java 和 Scala 两套 API，很容易开发应用程序，也能提供 SaaS。Akka 的 Actor 简化了多线程及其同步的操作，很容易编写云终端程序。

Actor 模型由 Carl Hewitt 在上世纪 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 处理。Akka 2.X 改善了扩展性（每个 Actor 大约 300Byte，每 GB 内存可创建数百万 Actor），简化了终端（Endpoint）或数据中心环境下分布式应用程序的创建。Akka 的其它特性包括：

1. 位置透明。Akka 使用 Actor 路径来实现位置透明性。一个 Actor 在 Akka 系统节点中的位置表示为

akka.<protocol>://<actor system>@<hostname>:<port>/<actor path>

<protocol> 是通信协议（如 tcp 和 udp）。<actor system> 是 Actor 系统的名字（传递给 ActorSystem 的 Actor 系统名字符串）。<hostname> 是 Actor 系统所在的主机名，也可以是 IP 字符串。<port> 是 Actor 系统的端口。<actor path> 是 Actor 系统的 Actor 路径，ActorSystem 创建的 Actor 位于 /user。在一台 IP 为 192.168.0.2 的主机，端口为 2552 上用名子为 actorSystemName 的 ActorSystem 创建的一个名子为 actorName 的 Akka Actor 可表示为

akka.tcp://actorSystemName@192.168.0.2: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

}

对于 remote Actor 的配置一般仅需修改 netty.tcp 中的 hostname 和 port。

3. 监督与监控，监控每一个 Akka 组件的错误或终止。Akka 实现的是 “父监管”，顶部的 Actor 由 Akka 提供，每一个子 Actor 都由它的父 Actor 监管。这种限制使得 actor 的树形层次有明确的形式。

4. 消息路由。Actor 发送的消息可以经过一个路由 Actor 或者软路由器转发至另一个 Actor。

用一个 Akka remote Actor 的例子说明开发过程。一共 4 个工程项目：dataType（定义的数据类型），akkaLocal（本地 Actor 系统，包括一个服务 Actor，负责与用户 Actor 交互，是控制节点），akkaRemote（远程 Actor 系统，负责计算任务，是计算节点），akkaUser（用户 APP Actor，，是客户端）。开发工具为 Eclipse（Winows 版本，eclipse-jee-kepler-SR2-win32-x86_64.zip。Linux 版本，eclipse-jee-kepler-SR2-linux-gtk-x86_64.tar.gz），Scala-IDE 插件（Eclipse 4.3-scala2.11.1-update-site.zip）。开发语言为 scala-2.11.1（Windows 和 Linux 版本）。Akka 为 2.3.4 版本（Windows 和 Linux 版本）。本地操作系统为 Windows 8.1 中文，在本地系统用 VirtualBox 安装一个 Kubuntu14.04，akkaLocal 和 akkaUser 运行在 Windows 8.1 上，akkaRemote 运行在 Kubuntu14.04 上。

Windows 系统配置如下：

处理器：Inter Core i7-4702MQ CPU@2.20GHz，4 核

内存：8G

系统类型：64 位 Windows 8.1

Linux 系统配置如下：

处理器：VirtualBox 虚拟 CPU，1 核

内存：2G

系统类型：64 位 Kubuntu14.04 桌面版

网络：

300Mbps 无线网，VirtualBox 桥接网卡

Windows IP：192.168.0.2，Kubuntu IP：192.168.0.16

认为读者熟练使用 Eclipse 及其插件，Scala-2.11.1 和 Akka-2.3.4 已安装好（Windows 8.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 包中新建 Scala Class，源文件为 MsgData.scala，修改代码如下：

package dataType

class MsgData(var msg:String) {

def this()

{

this("Message")

}

case object Start

case class Message(msg: String)

case class MessageInt(a:Int,b:Int)

object Demo extends App {

println("This is a message data library package:")

println("class MsgData(var msg:String)")

println("case object Start")

println("case class Message(msg: String)")

println("case class 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 包中新建 Scala Application，源文件为 HelloRemote.scala，代码如下：

package remote

import akka.actor._

import akka.remote._

import dataType._

class RemoteActor extends Actor {

def receive = {

case msg: String => {

println(s"RemoteActor received message ''$msg''")

//sender ! "k"

}

case MessageInt(a,b) => {

println(" RemoteActor got MesageInt:"+a+"*"+b)

sender ! ( a*b)

}

case _ =>

println(" RemoteActor got something unexpected.")

}

object HelloRemote extends App {

val system = ActorSystem("HelloRemoteSystem")

val remoteActor = 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 计算节点的错误，可以在远程计算节点主机上运行命令 sudo fuser -k -n tcp 5150，然后再重新运行 akkaRemote。

在 Windows 系统下，Eclipse 中创建 Scala 工程 akkaLocal，用于接收和执行 akkaUser 请求的计算服务消息命令，在 src 下创建 local 包，添加 PrjLibrary 库，Scala-2.11.1 库和 Akka-2.3.4 库。在 local 包中新建 Scala Application，源文件为 Local.scala，代码如下

package local

import akka.actor._

import akka.remote._

import dataType._

object Local extends App {

implicit val system = ActorSystem("LocalSystem")

val localActor = system.actorOf(Props[LocalActor], name = "LocalActor") // the local actor

localActor ! "START" // start the action

}

class LocalActor extends Actor {

// create the remote actor

val remote = context.actorSelection("akka.tcp://HelloRemoteSystem@192.168.0.16:5150/user/RemoteActor")

var svr = context.actorOf(Props[ServerActor], name = "server")

context.watch(svr)

def receive = {

case "START" => {

println("LocalActor received START")

remote ! "Hello from the LocalActor"

}

case msg:String => {

//sender ! "a"

println(s"LocalActor received message: ''$msg''")

}

case MessageInt(a,b) => {

println("Received task from user:"+MessageInt(a,b).toString())

remote ! MessageInt(a,b)

}

case resultInt:Int => {

svr ! resultInt

}

case _ =>

println("LocalActor got something unexpected.")

}

class ServerActor extends Actor {

var localAct = context.actorSelection("akka://LocalSystem/user/LocalActor")

var user1 = context.actorSelection("akka://LocalSystem/user/LocalActor")

def receive = {

case "START" => {

println("ServerActor received START")

}

case MessageInt(a,b) => {

localAct ! MessageInt(a,b)

user1=context.actorSelection(sender.path.toString())

println("ServerActor user1 path:"+sender.path.toString())

}

case resultInt:Int => {

user1 ! resultInt

}

case _ =>

println("LocalActor got something unexpected.")

}

LocalActor 的 receive 方法接收到一个 MessageInt(a,b) 消息后，将消息分发给 remote

（RemoteActor），remote 计算 a*b 后将结果发回，LocalActor 的 receive 方法接收到结果后，再将结果发给子 Actor svr（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 文件复制进去。在 Windows cmd 窗口下进入 akkaLocal.jar 文件的目录运行 java -jar akkaLocal.jar 可启动服务。

在 Windows 系统下，Eclipse 中创建 Scala 工程 akkaUser，用作客户端向 akkaLocal 发送用户请求的计算服务消息执行命令，在 src 下创建 akkauser 包，添加 PrjLibrary 库，Scala-2.11.1 库和 Akka-2.3.4 库。在 akkauser 包中新建 Scala Application，源文件 AkkaUser.scala，代码如下：

package akkauser

import akka.actor._

import akka.remote._

import dataType._

object AkkaUser extends App {

implicit val system = ActorSystem("AppUserSystem")

val appActor = system.actorOf(Props[AppActor], name = "AppUserActor") // the local actor

appActor ! "START"

}

class AppActor extends Actor {

var server = context.actorSelection("akka.tcp://LocalSystem@192.168.0.2:2562/user/LocalActor/server")

var x=0

def receive = {

case "START" => {

println("AppActor received START")

server ! MessageInt(1,1)

}

case rst:Int => {

println("result from server:"+rst)

x+=1

if(x>10) x=0

server ! MessageInt(2,x)

}

AppActor 收到一个 "START" 启动命令后，向 LocalActor 的子 Actor server 发送一个 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 中 run akkaRemote，然后在 Windows 的 cmd 中运行 akkaLocal.jar，最后在 Windows 下的 Eclipse 中 run akkaUser。 akkaRemote 的运行如下图 7 所示：

akkaLocal.jar 的运行如下图 8 所示：

akkaUser 的运行如下图 9 所示：

此时的 Windows 系统网络资源如下图 10 所示：

Windows 系统 CPU 资源如下图 11 所示：

Kubuntu 系统资源如下图 12 所示：

以上是在计算一个乘法操作情况下的系统资源，占用的网络带宽在 500~600Kps，如果计算一个加法操作占用的网络带宽在 1.5~1.6Mps，如果仅发送一个字节的字符串占用的网络带宽在 6Mps 左右。

本例仅仅使用了 Akka 的远程 Actor 就可以构建一个简单的云计算模型，具有本地服务节点，远程计算节点和客户端的功能，如果再运用 Akka 的集群管理功能和 Play2 web 框架就可以构建功能强大的云计算应用。

Akka v2.4.10_2.12.0-RC1，Actor 模型开发库

Akka v2.4.10_2.12.0-RC1 发布了。Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。本次主要的更新内容是将 Scala 升级至 2.12.0-RC1。

暂无发现其他更新内容，相关链接：

http://akka.io/news/
https://github.com/akka/akka/releases/tag/v2.4.10_2.12.0-RC1
https://github.com/akka/akka/compare/v2.4.10_2.12.0-RC1...master

下载地址：

http://akka.io/downloads/
Source code (zip)
Source code (tar.gz)

今天的关于JActor 4.2.0 RC1 发布，Actor 模式的 Java 实现和actor模型 java的分享已经结束，谢谢您的关注，如果想了解更多关于Akka 2.4 RC1 发布，Actor 开发模型库、Akka 2.5.0-RC1 发布，Actor 模型开发库、Akka Actor 模型云计算架构以及 Remote Actor 的简单示例、Akka v2.4.10_2.12.0-RC1，Actor 模型开发库的相关知识，请在本站进行查询。

本文标签：