Question

制作人演员可以向另一个演员发布消息以立即处理吗？即将消息发布到Consumer MailBox的头部而不是消费者邮箱的尾部？

我知道akka提供了一种配置我自己定义的邮箱类型的方法，但是如何控制是否需要在MailBox的头部而不是尾部发布某种类型的消息。例如TimerMessages。我想要一个精确的计时器控制时间窗实现。消息必须保留1000毫秒（比方说），如果消息处理消耗时间并且mailBox中有许多未决消息，我不希望将定时消息附加到同一队列。

我可以使用PriorityMailBox，但PriorityMailBox的问题在于，即使它可以在MailBox的头部放置更高优先级的消息（计时器消息），对于具有相同优先级的消息，该命令MailBox中的邮件不保证与到达顺序相同。所以我也不能使用priorityMailBox。

有人可以告诉我如何实现这种行为吗？

Answer 1

您可以使用自己的PriorityMailBox来处理邮件的到达时间，并将其用作附加优先级（对于具有相同“主要”优先级的邮件）。

像这样（未经测试）：

import akka.dispatch._
import com.typesafe.config.Config
import akka.actor.{ActorRef, PoisonPill, ActorSystem}
import java.util.Comparator
import java.util.concurrent.PriorityBlockingQueue

class MyTimedPriorityMailbox(settings: ActorSystem.Settings, config: Config)
  extends UnboundedTimedPriorityMailbox(
    TimedPriorityGenerator {
      case 'highpriority ⇒ 0

      case 'lowpriority  ⇒ 2

      case PoisonPill    ⇒ 3

      case otherwise     ⇒ 1
    })

case class TimedEnvelope(envelope: Envelope) {
  private val _timestamp = System.nanoTime()
  def timestamp = _timestamp
}

class UnboundedTimedPriorityMailbox( final val cmp: Comparator[TimedEnvelope], final val initialCapacity: Int) extends MailboxType {
  def this(cmp: Comparator[TimedEnvelope]) = this(cmp, 11)
  final override def create(owner: Option[ActorRef], system: Option[ActorSystem]): MessageQueue =
    new PriorityBlockingQueue[TimedEnvelope](initialCapacity, cmp) with TimedQueueBasedMessageQueue with TimedUnboundedMessageQueueSemantics {
      override def queue: java.util.Queue[TimedEnvelope] = this
    }
}

trait TimedQueueBasedMessageQueue extends MessageQueue {
  def queue: java.util.Queue[TimedEnvelope]
  def numberOfMessages = queue.size
  def hasMessages = !queue.isEmpty
  def cleanUp(owner: ActorRef, deadLetters: MessageQueue) {
    if (hasMessages) {
      var envelope = dequeue()
      while (envelope ne null) {
        deadLetters.enqueue(owner, envelope)
        envelope = dequeue()
      }
    }
  }
}

trait TimedUnboundedMessageQueueSemantics extends TimedQueueBasedMessageQueue {
  def enqueue(receiver: ActorRef, handle: Envelope) { queue add TimedEnvelope(handle) }
  def dequeue(): Envelope = Option(queue.poll()).map(_.envelope).getOrElse(null)
}


object TimedPriorityGenerator {
  def apply(priorityFunction: Any ⇒ Int): TimedPriorityGenerator = new TimedPriorityGenerator {
    def gen(message: Any): Int = priorityFunction(message)
  }
}


abstract class TimedPriorityGenerator extends java.util.Comparator[TimedEnvelope] {
  def gen(message: Any): Int

  final def compare(thisMessage: TimedEnvelope, thatMessage: TimedEnvelope): Int = {
    val result = gen(thisMessage.envelope.message) - gen(thatMessage.envelope.message)
    // Int.MaxValue / Int.MinValue check omitted
    if(result == 0) (thisMessage.timestamp - thatMessage.timestamp).toInt else result
  }

}

Answer 2

上面的代码工作正常。

只有一个细节。避免使用System.getTimeNano（）。它在多核机器中存在问题，因为它由per-cpu逻辑

定义

Here another post

然后，我们在消息顺序中有一个奇怪的行为取决于哪个cpu enque它。

我用经典的System.currentTimeMillis（）更改它。它不太精确，但在我们的情况下，如果两条具有相同优先级且具有相同毫秒生成时间的消息，则不关心它们的处理顺序。

感谢您的代码！

akka演员向MailBox的负责人发帖子

2 个答案: