Scala: What is the difference between while(true) and loop?

Question

I don't get the actual (semantic) difference between the two "expressions".
It is said "loop" fits to "react" and "while(true)" to "receive", because "react" does not return and "loop" is a function which calls the body again all over again (it least this is what I deduct from the sources - I am not really familiar with the used "andThen"). "Receive" blocks one Thread from the pool, "react" does not. However, for "react" a Thread is looked up which the function can be attached to.

So the question is: why can't I use "loop" with "receive"? It also seems to behave different (and better!) than the "while(true)" variant, at least this is what I observe in a profiler. Even more strange is that calling a ping-pong with "-Dactors.maxPoolSize=1 -Dactors.corePoolSize=1" with "while(true)" and "receive" blocks immediately (that's what I would expect) - however, with "loop" and "receive", it works without problems - in one Thread - how's this?

Thanks!

Answer 1

The method loop is defined in the object Actor:

private[actors] trait Body[a] {
  def andThen[b](other: => b): Unit
}

implicit def mkBody[a](body: => a) = new Body[a] {
  def andThen[b](other: => b): Unit = self.seq(body, other)
}

/**
 * Causes <code>self</code> to repeatedly execute
 * <code>body</code>.
 *
 * @param body the code block to be executed
 */
def loop(body: => Unit): Unit = body andThen loop(body)

This is confusing, but what happens is that the block that comes after loop (the thing between { and }) is passed to the method seq as first argument, and a new loop with that block is passed as the second argument.

As for the method seq, in the trait Actor, we find:

private def seq[a, b](first: => a, next: => b): Unit = {
  val s = Actor.self
  val killNext = s.kill
  s.kill = () => {
    s.kill = killNext

    // to avoid stack overflow:
    // instead of directly executing `next`,
    // schedule as continuation
    scheduleActor({ case _ => next }, 1)
    throw new SuspendActorException
  }
  first
  throw new KillActorException
}

So, the new loop is scheduled for the next action after a kill, then the block gets executed, and then an exception of type KillActorException is thrown, which will cause the loop to be executed again.

So, a while loop performs much faster that a loop, as it throws no exceptions, does no scheduling, etc. On the other hand, the scheduler gets the opportunity to schedule something else between two executions of a loop.

Answer 2

The critical difference between while and loop is that while restricts the loop iterations to occur in the same thread. The loop construct (as described by Daniel) enables the actor sub-system to invoke the reactions on any thread it chooses.

Hence using a combination of receive within while (true) ties an actor to a single thread. Using loop and react allows you run support many actors on a single thread.