将映射转换为字符串时意外删除

Question

abstract trait SchedulingActor[I <: SchedulingActor.Item[I]] extends Actor {

    private val log = LoggerFactory.getLogger(classOf[SchedulingActor[I]])

    private var schedule = Map[Ticket, (I, Cancellable)]()
    private var ticketMap = Map[Int, Ticket]()

    protected def delay(msg: Any, item: I): Cancellable
    protected def initiate(item: I): Unit

    protected def schedule(item: I) = self ! item

    private def currentTickets(item: I) = item.ids.flatMap(ticketMap.get(_))
    protected def linkedItems(ids: Seq[Int]) = ids.flatMap(ticketMap.get(_)).map(schedule(_)._1)

    protected case class Ticket() {

        def collect(item: I) = {
            schedule += this -> (item, delay(this, item))
            ticketMap ++= item.ids.map(_ -> this)
        }

        def update(item: I) = {
            schedule += this -> (item, schedule(this)._2)
        }

        def cancel() = {
            schedule(this)._1.cancel()
            schedule(this)._2.cancel()
            drop()
        }

        def drop() = {
            ticketMap = ticketMap.filterKeys(!schedule(this)._1.ids.contains(_))
            schedule -= this
        }

        def item = schedule(this)._1
    }

    def receive = {

        case item: I =>
            // Check if we're overwriting any currently scheduled
            try {
                log.debug("Scheduling item: " + item)
                log.debug("Checking for tickets: " + ticketMap)
            }
            catch {
                case ex: Throwable =>
                    log.error("Strange error", ex)
            }
            currentTickets(item).foreach { ticket =>
                log.debug("Checking current ticket: " + ticket)
                ticket.item.purge(item) match {
                    case upd if upd.ids.nonEmpty =>
                        log.debug("Updating schedule: " + upd)
                        ticket.update(upd)
                    case _ =>
                        log.debug("Cancelling ticket: " + ticket)
                        ticket.cancel()
                }
            }
            // Schedule the replacement now
            log.debug("Collecting ticket for: " + item)
            Ticket().collect(item)
            log.debug("Scheduled replacement: " + item)

        case ticket: Ticket =>
            initiate(ticket.item)
            ticket.drop()
    }
}

object SchedulingActor {

    trait Item[T <: Item[T]] {
        val ids: Set[Int]
        def cancel(): Unit
        def purge(newItem: T): T
    }
}

在将ticketMap转换为字符串时，它究竟为什么要尝试调用“drop”方法？

Answer 1

通过检查堆栈跟踪，我可以推断出问题源于方法drop()，特别是下面一行：

ticketMap = ticketMap.filterKeys(!schedule(this)._1.ids.contains(_))

通过将其更改为：

    ticketMap = ticketMap.filterNot(kv => schedule(this)._1.ids.contains(kv._1))

我假设filterKeys的实现使用与mapKeys类似的机制，后者使用惰性计算。因此，直到下一次引用ticketMap时才调用filterKeys，此时消息已经处理完毕。这显然不是我们想要的行为。