可以自己做网站的软件/中国十大经典广告
Akka Actor其具有以下特点：
- 系统中的所有事物都可以扮演一个Actor
- Actor之间完全独立
- 在收到消息时，Actor所采取的所有动作都是并行的，在一个方法中的动作没有明确的顺序
- Actor有标识和当前行为描述
- Actor可能被分成原始和非原始类别
- 非原始Actor有一个由邮件地址表示的标识
- 当前行为由一组知识（实例变量或本地状态）和定义Actor在收到消息时将采取的动作组成
- 消息传递是非阻塞和异步的，其机制是邮件队列
- 所有消息发送都是并行的。
绝大多数流行语言的并发是基于多线程之间的共享内存，使用同步方法防止写争夺，但Akka提供的则是基于Actor的并发模型。
Akka将复杂的Actor通信、Actor注册、Actor查找进行了封装。用户在写自己的Actor时，只需要实现akka.actor.Actor这个接口。
在Akka框架中，每一个Actor都有一个唯一的URL，该URL的定义格式和万维网地址的定义格式非常相似。
每一个Actor通过ActorSystem和Context初始化的时候，都会得到自己唯一的路径，路径格式如：akka.tcp://systemName@ip:port/user/topActorName/otherActorName，并且可以通过actorSelection(path)方法查找对应路径的Actor对象，该方法返回该Actor的引用。得到Actor后就可以发送消息了。
创建Actor
（1）通过实现akka.actor.Actor来创建Actor类
要定义自己的Actor类，需要继承Actor并实现receive方法。receive方法需要定义一系列case语句，来描述Actor能够处理哪些消息（使用标准的Scala模式匹配），以及实现对消息如何进行处理的代码。
import akka.actor._
object HelloScala {def main(args: Array[String]): Unit = {val _system = ActorSystem("HelloScalaNo7")// Props[MyActor]这里一定要写对val myActor = _system.actorOf(Props[MyActor],"iLoveMyActor")myActor ! "Hello My love"}
}
class MyActor extends Actor{override def receive: Receive = {case str: String => println(str)case _ =>}
}Akka Actor receive消息循环是“无穷无尽的”。在receive方法中，提供一个对它能够接受消息的匹配规则，如果希望处理未知的消息，可以像上述代码中一样提供一个缺省的case分支，否则会有akka.actor.UnhandledMessage(message,sender,recipient)被发布到Actor系统（ActorSystem）的事件（EventStream）中。
上述代码中的actorOf的调用将返回一个实例的引用，这个引用是Actor访问句柄，可以用它来与实际的Actor进行交互。
ActorRef是不可变量，与它所代表的Actor之间是一对一的关系。ActorRef是可序列化的，并且它携带了网络信息。这意味着可以将它序列化以后，通过网络进行传送，在远程主机上它仍然代表原结点上的同一个Actor。
上述代码中，Actor是从系统创建的。也可以在其他的Actor中，使用Actor上下文（context）来创建，其中的区别在于监管树的组织方式。使用上下文时当前Actor将成为其创建子Actor的监管者。而使用系统创建的Actor将成为顶级Actor，它由系统（内部监管Actor）来监管。
(2)使用Actor的context创建Actor：
import akka.actor._
object HelloScala {def main(args: Array[String]): Unit = {val _system = ActorSystem("HelloScala")// firstActor是使用系统创建的Actor，它将成为顶级Actor，它由系统（内部监管Actor）来监管。val firstActor = _system.actorOf(Props[FirstActor],"firstActor")firstActor ! "Hello MyActor!How are you?"}
}class MyActor extends Actor{override def receive: Receive = {case str: String => println(s"test actor receive # ${str}")case _ =>}
}class FirstActor extends Actor{// context 方法创建Actor,使用上下文时当前Actor将成为其创建子Actor的监管者,所以FirstActor成为MyActor的监管者val myActor = context.actorOf(Props[MyActor],"myActor")// 输出监管目录println(s"MyActor's monitor#${myActor.path.parent.getElements.toString}")// Actor启动，preStart方法自动调用override def preStart(): Unit = println("FirstActor's preStart method was called!")override def receive: Receive = {case msg => myActor ! msg // 发给MyActorcase _ =>}
}
（3）使用非缺省构造方法创建Actor
如果Actor的构造方法带参数，那么就不能使用actorOf(Props[TYPE])来创建。可以使用actorOf的非缺省构造方法，这样就可以用任意方式来创建Actor了。
import akka.actor._
object HelloScala {def main(args: Array[String]): Unit = {// 创建名为HelloAkka的ActorSystemval _system = ActorSystem("HelloAkka")// 非缺省构造方法创建，在Props中new 一个Test，并传入参数goatval testActor = _system.actorOf(Props(new Test("goat")),"testActor")testActor ! "Look at the stars!"}
}class Test(name: String) extends Actor{// Actor启动，自动调用preStart方法override def preStart(): Unit = println("Test Actor preStart method was called!")override def receive: Receive = {// 匹配打印消息case str: String => println(s"actor's name:${name}#testActor receive msg:${str}")// 缺省处理case _ =>}
}
(4)创建匿名Actor
从某个Actor中派生新的Actor来完成特定的子任务时，可能使用匿名类来包含将要执行的代码会更方便。
import akka.actor._
object HelloScala {def main(args: Array[String]): Unit = {// 创建名为HelloAkka的ActorSystemval _system = ActorSystem("HelloAkka")// 使用ActorSystem的actorOf工厂方法创建Test4 Actorval test4Actor = _system.actorOf(Props[Test4],"test4Actor")test4Actor ! "Look at the stars!HO HO HO "}
}class Test4 extends Actor{// Actor启动，自动调用preStart方法override def preStart(): Unit = println("Test4 Actor preStart method was called!")override def receive: Receive = {// 匹配打印消息case str: String =>// 使用context的actorOf方法创建Actorcontext.actorOf(Props(new Actor {// 创建匿名Actoroverride def receive: Receive = {case msg: String =>println(s"anonymous Actor receive message#${msg}")context.stop(self) // 停止匿名Actor}})).forward(str)// forward会把消息转发给刚刚定义的匿名Actor// 缺省处理case _ =>}
}
采用匿名Actor的方式，需要小心地避免捕捉外层Actor的引用，不要在匿名的Actor类中调用外层Actor的方法，这样会破坏Actor的封装，可能会引入同步bug和资源竞争，因为其他的Actor可能会与外层Actor同时进行调度。