GVKun编程网logo

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

2

对于想了解JActor4.0.0发布，Actor模式的Java实现的读者，本文将是一篇不可错过的文章，我们将详细介绍actor模型java，并且为您提供关于13种提升MVVM模式的WP7程序性能的方法

对于想了解JActor 4.0.0 发布，Actor 模式的 Java 实现的读者，本文将是一篇不可错过的文章，我们将详细介绍actor模型 java，并且为您提供关于13 种提升 MVVM 模式的 WP7 程序性能的方法、Akka Actor 模型云计算架构以及 Remote Actor 的简单示例、CC3200 在 AP 模式的 TCP sock 作为客户端连接时返回 SL_ECONNREFUSED (-111) Connection refused、django 中 FBC 和 CBV 模式的 urls 和 views 的对应写法的有价值信息。

本文目录一览：

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

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

JActor 4.0.0 发布，该版本移除了前一个版本中废弃的方法和类。

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();
}

13 种提升 MVVM 模式的 WP7 程序性能的方法

13 种提升 MVVM 模式的 WP7 程序性能的方法

1，不要在 UI 线程上处理大量计算 -- 如果可以的话，尽量避免在 UI 线程上做长时间运算，尽量让 UI 能够响应

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

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 框架就可以构建功能强大的云计算应用。





CC3200 在 AP 模式的 TCP sock 作为客户端连接时返回 SL_ECONNREFUSED (-111) Connection refused

CC3200 在 AP 模式的 TCP sock 作为客户端连接时返回 SL_ECONNREFUSED (-111) Connection refused

1. CC3200 处于 AP 模式（电脑无线连接 CC3200 的 WIFI 信号），开启一个 TCP socket，这个 socket 作为 TCP 客户端去连接 TCP 服务器端

  struct sockaddr_in addr;
  unsigned long  g_ulDestinationIp;
  long lRetVal = -1; 
  memset((char*)&addr, 0, sizeof(addr));
  
  addr.sin_family = SL_AF_INET;
  addr.sin_port = htons((unsigned short)port);
  g_ulDestinationIp = inet_addr(doName);
  addr.sin_addr.s_addr = sl_Htonl((unsigned int)g_ulDestinationIp);
  fd = sl_Socket(SL_AF_INET, SL_SOCK_STREAM, 0);
  if (fd < 0)
  {
    close(fd);
    return -1;
  }
 lRetVal = sl_Connect(fd, (sockaddr *)&addr, sizeof(sockaddr));
  if (lRetVal < 0)
  {
    close(fd);
    return -1;
  }

但是返回

#define SL_ECONNREFUSED                       (-111) /* Connection refused */

2. 经过测试发现，很多人使用电脑的时候，有线网卡和无线网卡都是开启的，有线网卡开启的时候会获取到一个 IP 地址，电脑作为 STA 模式连接到 CC3200 的时候也会获取到一个 IP 地址，但是需要注意，在使用 CC3200 创建 socket 的时候，目的 IP 地址和端口一定要填写电脑无线网卡的 IP 地址。使用

 

django 中 FBC 和 CBV 模式的 urls 和 views 的对应写法

django 中 FBC 和 CBV 模式的 urls 和 views 的对应写法

FBV

urls：

urlpatterns = [

　 url(r''^admin/'', admin.site.urls),
 　url(r''^home/'', views.home),
]

views:

def home(request):
 　　return render(request, ''home.html'')

 

CBV

urls：

urlpatterns = [

   url(r''^admin/'', admin.site.urls),
　url (r''^home/'', views.Home.as_view ()), #固定写法　
]

views:

from django.views import View
class Home(View):

　　def get(self,request):
　　　　print(request.method)
　　　　return render(request, ''home.html'')

　　def post(self,request):
　　　　print(request.method,''POST'')
　　　　return render(request, ''home.html'')

 

方式二：

　　

from django.views import View
class Home(View):

　　def dispatch (self, request, *args, **kwargs):   # 反射调用 类中的方法     其实和上面的写法一样
　　　　# 调用父类中的 dispatch
　　　　print(''before'')
　　　　result = super(Home,self).dispatch(request, *args, **kwargs)
　　　　print(''after'')
　　　　return result

　　def get(self,request):
　　　　print(request.method)
　　　　return render(request, ''home.html'')

　　def post(self,request):
　　　　print(request.method,''POST'')
　　　　return render(request, ''home.html'')

 

今天关于JActor 4.0.0 发布，Actor 模式的 Java 实现和actor模型 java的分享就到这里，希望大家有所收获，若想了解更多关于13 种提升 MVVM 模式的 WP7 程序性能的方法、Akka Actor 模型云计算架构以及 Remote Actor 的简单示例、CC3200 在 AP 模式的 TCP sock 作为客户端连接时返回 SL_ECONNREFUSED (-111) Connection refused、django 中 FBC 和 CBV 模式的 urls 和 views 的对应写法等相关知识，可以在本站进行查询。

本文标签：

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

下一篇JActor 4.1.0 发布，Actor 模式的 Java 实现（actor模型 java）

相关文章