How to create non-blocking methods in Scala?

Question

What is a good way of creating non-blocking methods in Scala? One way I can think of is to create a thread/actor and the method just send a message to the thread and returns. Is there a better way of creating a non-blocking method?

Answer 1

Learn about actors.

Answer 2

Use scala.actors.Future:

import actors._

def asyncify[A, B](f: A => B): A => Future[B] = (a => Futures.future(f(a)))

// normally blocks when called
def sleepFor(seconds: Int) = {
  Thread.sleep(seconds * 1000)
  seconds
}

val asyncSleepFor = asyncify(sleepFor)
val future = asyncSleepFor(5) // now it does NOT block
println("waiting...")         // prints "waiting..." rightaway
println("future returns %d".format(future())) // prints "future returns 5" after 5 seconds

Overloaded "asyncify" that takes a function with more than one parameter is left as an exercise.

One caveat, however, is exception handling. The function that is being "asyncified" has to handle all exceptions itself by catching them. Behavior for exceptions thrown out of the function is undefined.

Answer 3

It depends on your definition of "blocking." Strictly speaking, anything that requires acquisition of a lock is blocking. All operations that are dependent on an actor's internal state acquire a lock on the actor. This includes message sends. If lots of threads try to send a message to an actor all-at-once they have to get in line.

So if you really need non-blocking, there are various options in java.util.concurrent.

That being said, from a practical perspective actors give you something that close enough to non-blocking because none of the synchronized operations do a significant amount of work, so chances are actors meet your need.