Akka源码分析-Router

　　 akak中还有一个比较重要的概念，那就是Router（路由）。路由的概念，相信大家都不陌生，在akka中，它就是其他actors的一个代理，会把消息按照路由规则，分发给指定的actor。我一般喜欢把Router用作负载均衡。

　　其实如果不看官方的源码或不使用官方Router，我们自己实现一个router也还是很简单的，因为一共有三个重要的概念：路由、路由策略、路由对象。路由负责接收消息，按照路由策略把消息传递给路由对象。在akka中，路由和路由对象都是一个普通的actor，只不过路由策略需要我们涉及的通用些，能够支持各种路由算法就好了。不过既然官方实现了Router，就研读一下喽。

　　老规矩，还是从官方demo入手，分析Router的相关源码。

    import akka.routing.{ ActorRefRoutee, RoundRobinRoutingLogic, Router }

    class Master extends Actor {
      var router = {
        val routees = Vector.fill(5) {
          val r = context.actorOf(Props[Worker])
          context watch r
          ActorRefRoutee(r)
        }
        Router(RoundRobinRoutingLogic(), routees)
      }

      def receive = {
        case w: Work ⇒
          router.route(w, sender())
        case Terminated(a) ⇒
          router = router.removeRoutee(a)
          val r = context.actorOf(Props[Worker])
          context watch r
          router = router.addRoutee(r)
      }
    }

 　　很简单，上面master启动的时候，通过actorOf创建了5个Worker，然后收到Work消息时，调用routee分发消息。当然了在收到worker的Terminated消息后，又重新创建了一个worker。这只是router的一个用法，我个人是不喜欢的，因为它定死了worker的个数。

/**
 * For each message that is sent through the router via the [[#route]] method the
 * [[RoutingLogic]] decides to which [[Routee]] to send the message. The [[Routee]] itself
 * knows how to perform the actual sending. Normally the [[RoutingLogic]] picks one of the
 * contained `routees`, but that is up to the implementation of the [[RoutingLogic]].
 *
 * A `Router` is immutable and the [[RoutingLogic]] must be thread safe.
 */
final case class Router(val logic: RoutingLogic, val routees: immutable.IndexedSeq[Routee] = Vector.empty)

 　　上面是Router的定义，这居然是一个case class，有两个变量：路由逻辑（RoutingLogic）、路由对象（IndexedSeq[Routee]）。

/**
 * The interface of the routing logic that is used in a [[Router]] to select
 * destination routed messages.
 *
 * The implementation must be thread safe.
 */
trait RoutingLogic extends NoSerializationVerificationNeeded {
  /**
   * Pick the destination for a given message. Normally it picks one of the
   * passed `routees`, but in the end it is up to the implementation to
   * return whatever [[Routee]] to use for sending a specific message.
   *
   * When implemented from Java it can be good to know that
   * `routees.apply(index)` can be used to get an element
   * from the `IndexedSeq`.
   */
  def select(message: Any, routees: immutable.IndexedSeq[Routee]): Routee

}

 　　上面是RoutingLogic的定义，要不要这么简单呢？就只有一个select函数，它根据message和路由对象集合返回了一个路由目标。

/**
 * Abstraction of a destination for messages routed via a [[Router]].
 */
trait Routee {
  def send(message: Any, sender: ActorRef): Unit
}

 　　路由对象是啥呢？就是一个只包含send方法的trait，也非常简单。其实吧，路由对象只要能发送消息就行了，不管他是ActorRef还是ActorSelection。

 

　　上面是Router的完整源码，一共分四部分功能：路由消息、给指定路由对象发送消息、路由对象操作、消息解包。

 /**
   * Send the message to the destination [[Routee]] selected by the [[RoutingLogic]].
   * If the message is a [[akka.routing.RouterEnvelope]] it will be unwrapped
   * before sent to the destinations.
   * Messages wrapped in a [[Broadcast]] envelope are always sent to all `routees`.
   */
  def route(message: Any, sender: ActorRef): Unit =
    message match {
      case akka.routing.Broadcast(msg) ⇒ SeveralRoutees(routees).send(msg, sender)
      case msg                         ⇒ send(logic.select(msg, routees), message, sender)
    }

 　　route方法非常简单，首先判断是不是广播消息，如果是就创建SeveralRoutees然后发送；如果不是则调用logic.select选择一个routee，然后调用send发送。先来分析SeveralRoutees

 

/**
 * [[Routee]] that sends each message to all `routees`.
 */
final case class SeveralRoutees(routees: immutable.IndexedSeq[Routee]) extends Routee {

  /**
   * Java API
   */
  def this(rs: java.lang.Iterable[Routee]) = this(routees = immutableSeq(rs).toVector)

  /**
   * Java API
   */
  def getRoutees(): java.util.List[Routee] = {
    import scala.collection.JavaConverters._
    routees.asJava
  }

  override def send(message: Any, sender: ActorRef): Unit =
    routees.foreach(_.send(message, sender))
}

 

 　　SeveralRoutees首先这是一个Routee，然后覆盖了send方法，send里面依次调用routees集合的send方法。由于在Broadcast（广播）消息传入了整个routees，所以也就是给当前路由的所有路由对象都发送了消息。怎么样，是不是非常简单呢？

　　既然router和routerLogic都这么简单，而且他们只接收Routee，那么跟ActorRef和ActorSelection如何关联呢？看到官方demo中的ActorRefRoutee了吗？

/**
 * [[Routee]] that sends the messages to an [[akka.actor.ActorRef]].
 */
final case class ActorRefRoutee(ref: ActorRef) extends Routee {
  override def send(message: Any, sender: ActorRef): Unit =
    ref.tell(message, sender)
}

 　　ActorRefRoutee就是对ActorRef的封装，它覆盖send方法，调用ActorRef的tell方法把消息发送出去。就是这么简单，那ActorSelection也是这样喽？对的，就是这样。

/**
 * [[Routee]] that sends the messages to an [[akka.actor.ActorSelection]].
 */
final case class ActorSelectionRoutee(selection: ActorSelection) extends Routee {
  override def send(message: Any, sender: ActorRef): Unit =
    selection.tell(message, sender)
}

 　　这是不是太简单了点？嗯，Router的基本用法就是这么简单啊。为了篇幅，我们简单分析几个路由策略，那就分析demo中的RoundRobinRoutingLogic吧。

/**
 * Uses round-robin to select a routee. For concurrent calls,
 * round robin is just a best effort.
 */
@SerialVersionUID(1L)
final class RoundRobinRoutingLogic extends RoutingLogic {
  val next = new AtomicLong

  override def select(message: Any, routees: immutable.IndexedSeq[Routee]): Routee =
    if (routees.nonEmpty) {
      val size = routees.size
      val index = (next.getAndIncrement % size).asInstanceOf[Int]
      routees(if (index < 0) size + index else index)
    } else NoRoutee

}

 　　请注意，在RoutingLogic定义中说需要满足线程安全，所以next是一个AtomicLong，至于为啥需要线程安全，这里先略过。不过如果你就是官方demo的用法，还要啥线程安全，真是浪费。

　　这个RoundRobinRoutingLogic的实现逻辑也很简单，就是对AtomicLong进行依次自增，然后对routees.size取余，取出对应index的routee即可。其实就是按照顺序返回列表中的元素Routee，如果到达列表末尾，则从头取值。这好像也简单了点。

• akka.routing.RoundRobinRoutingLogic。轮询路由策略。具体实现参照上文分析。
• akka.routing.RandomRoutingLogic。随机路由策略。就是从列表中随机选择一个Routee
• akka.routing.SmallestMailboxRoutingLogic。最小邮箱路由策略。就是选择各个Routee的邮箱堆积消息最少的一个。从源码来看这个是需要查找Routee的邮箱数量的，个人不太喜欢这种实现。

• akka.routing.BroadcastRoutingLogic。广播路由策略。就是把消息广播出去。
• akka.routing.ScatterGatherFirstCompletedRoutingLogic。广播收集第一个完成路由策略。有点拗口，简单来说就是把消息广播出去，以第一个收到的回复作为此次路由的回复。这个不建议用，因为它对所有Routee都调用了ask。如果不关心回复，则可以使用BroadcastRoutingLogic。
• akka.routing.TailChoppingRoutingLogic。尾部断续路由策略。跟ScatterGatherFirstCompletedRoutingLogic差不多，只不过不是广播，而是按照一个固定间隔的时间，依次给Routee发消息，收到第一个回复后，不再广播消息，以该回复作为最终回复。
• akka.routing.ConsistentHashingRoutingLogic。一致性hash路由策略。就是根据消息计算对应的key，key相同的消息会发送给相同的Routee。读者可以自行研究一致性HASH的实现，简单来说就是对消息和Routee都进行hash，hash相同的作为路由关系。

　　对于官方demo，有一点疑问，router是不是初始化必须要有值呢？而且必须是同类型的Actor呢？完全不必要。router初始化可以为空，且不一定必须是相同的Actor，只不过官方认为，既然你都它进行路由了，最好是相同类型的actor。其实吧，个人认为，路由是对消息来说的，只要路由对象能够处理该消息就行了，不必是相同类型的。Routees如何动态添加呢？我一般把需要路由消息的Actor（比如Worker），发特定消息告诉Master（也就是router），Master收到该消息后把ActorRef添加到Router中。这在remote和cluster中非常适用。

　　关于Router的基本概念和源码就分析完了，但官方对Router还有其他丰富的功能，比如RoundRobinPool和RoundRobinGroup，我个人不太喜欢这种实现，还是喜欢最基本的用法。感兴趣的读者可以自行阅读相关的源码。