Akka核心部件

Dispatcher是Akka的引擎，控制和协调信息并将其分发给运行在底层线程上的Actor，由他负责调度资源的优化。
Router是具有路由功能的Actor
基于Supervision和Monitoring实现的“Let it Crash”模型，通过定义Superivsion和监管策略，实现系统异常处理。
STM乐观锁

Dipatchers和Routers

Dispatcher运行在线程之上，负责分发其邮箱里面的Actors和Messages到executor中的线程上运行。
四种Dispatcher：
Dispatcher，
Pinned Dispatcher，
Balancing Dispatcher，
Calling Thread Diapatcher
四种邮箱：
Unbounded mailbox
Bounded mailbox
Unbounded priority mailbox
Bounded priority mailbox

为Actor指定派发器

非缺省：
1） 在实例化Actor时，指定派发器，

import akka.actor.Props
 val myActor =context.actorOf(Props[MyActor].withDispatcher(“my-dispatcher”),”myactor1”)

2)
创建Actor时，使用withDispatcher指定派发器为my-dispatcher，然后在application.conf配置文件中指定派发器，

my-dispatcher{
type=Dispatcher
executor=”fork-join-executor”
fork-join-executor{
parallelism-min=2
parallelism-factor=2,.0
parallelism-max=10
}
Throughput=100
}

派发器类型

1、 Dispatcher
*每一个Actor都有自己的邮箱
*该Dispatcher可以被任意数量的Actor共享。
*该Dispatcher可以由ThreadPoolExecutor或ForkJoinPool提供
*该Dispatcher是非闭塞的
2、Pinned Dispatcher
*每一个Actor都有自己的邮箱
*每一个Actor都有自己专用的线程，该线程不共享
*有一个Executor线程池
*在闭塞操作上进行优化
3、Balancing Dispatcher
基于事件，任务较多的Actor上的任务将被重新分配到较闲的Actor
*所有的Actor共用一个邮箱
*该Dispatcher只能被同一类型的的Actor共享。
*该Dispatcher可以由ThreadPoolExecutor或ForkJoinPool提供
4、Calling Thread Dispatcher
主要用于测试，在当前线程中运行，不会创建新的线程
*每一个Actor都有自己的邮箱
*该Dispatcher可以被任意数量的Actor共享。
*该Dispatcher由调用线程支持。

邮箱

用于保存接受的消息，除了使用Balancing Dispatcher 分发器的actor外，每个Actor拥有自己的邮箱，
1） Unbounded mailbox
底层有一个java.util.concurrent,ConcurrentLinkedQueue
阻塞：否
有界：否

2） Bounded mailbox
底层java.util.concurrent.LinkedBlockingQueue
阻塞：是
有界：是

3） Unbounded priority mailbox
底层java.util.concurrent.PriorityBlokingQueue
阻塞：是
有界：否

4）Bounded priority mailbox
底层java.util.PriorityBlockingQueue
阻塞：是
有界：是
5）持久邮箱

Routers

当大量的Actor并行处理流入时，路由Actor将消息发送给它所管理的称为router的Actor。
1） 轮流路由器，akka.routing.RoundRobinRouter,将传入的消息按轮转的顺序发送给router
2） 随机路由器：akka.routing..RandonRouter,随机选择选择一个router并将消息路由过去。
3） 最小邮箱路由器：akka.routing.SmallestMailboxRouter,选择邮箱里最小的router发送，
4） 广播路由器：akka.routing.BroadcastRouter.将相同的消息广播到所有的·routers
5） 敏捷路由器：akka.routing.ScatterGatherFirstCompletedRouter,Router先将消息广播到所有的routers，返回最先完成任务的router的结果给调用者

路由的使用

配置文件

akka.actor.deployment{
router{
riouter=round-robin//轮转路由器
nr-of-instances=5//routers个数为5个
}
}

在代码中直接使用
val router=system.actorOf(Props[ExampleActor].withRouter(FormConfig()),”router”)

代码实现
val router=system.actorOf(Props[ExampleActor1].withRouter(RoundRobinRouter（nrOfInatances=5)

远程部署router

import akka.actor.{Address,AddressFromURIString}
val adsress=Seq(address(“akka”,”remotesys”,”otherhost”,134)//Address设置，协议、远程//ActorSystem系统名称、Ip地址、端口号
AddressFromURIString(“akka://othersys@anotherhost:134”))
val routerRemote=system.actorOf(Props[ExampleActor1].withRouter(
RemoteRouterConfig(RouterRobiRouter(5),address)))

supervision和monitoring

supervision

监管描述的是Actor之间的关系：监管者将任务托管给下属并对下属的失败状况进行响应。当出现错误时，它会将自己和自己所有的下属挂起，然后向自己的监管者发送提示失败的消息。之后的行为分为以下四种：
1） 让下属继续执行，保持下属的当前内部状态
2） 重启下属，清楚下属的内部状态。
3） 永久地终止下属。
4） 将失败沿监管树向上传递
Actor只能由其它的Actor创建，顶部的Actor由系统创建。
路径树的最顶部是根监管。
第二层是
“/user”，是所有由用户创建的顶级的Actor，用ActorSystem.actorOf创建的Actor在其下一层次
“/system”，所有系统创建的顶级Actor的监管者
“/deadLetters”死信Actor，所有发往已终止的或不存在的Actor的消息会被送到这里
“/temp”系统创建的短时Actor的监管者
“/remote”用来存放所有其监管者是远程Actor引用的Actor，

监管策略：one-For-One
All-For-One

Monitoring

生命周期监控是向监控Actor发送Terminated消息，如果没有处理，默认抛出一个DeathpactException。
STM Software Transactional Memory 软件事务内存，多线程之间数据共享。

import concurrent.stm.Ref
val seats=Ref(Seq[Seat]())
seats()=seats().tail//更新共享变量

处于Ref包装中的seats变量，只能在atomic块中执行，在atomic块中写的代码将被视为一个原子命令被执行。

使用视图读取

seats.single.get//single方法返回Ref.View，在调用View的get方法
val myseat=seats.single.getAndTransform(_.tail)

读取Agent事务中的数据
1） 创建Agent

import scala.concurrent.ExecutionContext.Implicits.dlobal//引入隐式变量
import akka.agent.Agent
val agent=Agent(50)//创建Agent

2） 读取Agent，直接使用agent.get或agent()
3） 更新Agent更新Agent中的值，

agent send 60
agent send(_+10)
agent sendoff()
val future:Future[Int]=agent alter 60//改变值后，立即返回一个Future

借用大佬的代码来举例：http://blog.csdn.net/liubenlong007/article/details/54576412

以及另一个大佬：http://www.jdon.com/concurrent/akka1.html