CODEWITHSUNDEEP
scalaasynchronous
matanox
matanox

Reputation: 13686

Mixing in asynchronous code within plain synchronous flow in Scala

What is in your view the best scala solution for the case that you have some plain chain of synchronous function calls, and you need to add an asynchronous action in the middle of it without blocking?

I think going for futures entails refactoring existing code to callback spaghetti, tethering futures all the way through the formerly synchronous chain of function calls, or polling on the promise every interval, not so optimal but maybe I am missing some trivial/suitable options here.

It may seem that refactoring for (akka) actors, entail a whole lot of boilerplate for such a simple feat of engineering.

How would you plug in an asynchronous function within an existing synchronous flow, without blocking, and without going into a lot of boilerplate?

Right now in my code I block with Await.result, which just means a thread is sleeping...

Upvotes: 0

Views: 983

Answers (2)

experquisite
experquisite

Reputation: 879

You could also use the async/await library, with the caveat that you wind up with one big Future out of it that you still have to deal with:

http://docs.scala-lang.org/sips/pending/async.html

But, it results in code almost identical to the sychronous code; where you were previously blocking, you add an:

await { theAsyncFuture }

and then carry on with synchronous code.

Upvotes: 1

flavian
flavian

Reputation: 28511

One simple dirty trick:

Let's say you have:

def f1Sync: T1
def f2Sync: T2
...
def fAsynchronous: Future[TAsync]


import scala.concurrent.{ Future, Promise }


object FutureHelper {
  // A value class is much cheaper than an implicit conversion.
  implicit class FutureConverter[T](val t: T) extends AnyVal {
    def future: Future[T] = Promise.successful(t).future
  }

}

Then you can for yield:

import FutureHelper._

def completeChain: Future[Whatever] = {
  for {
    r1 <- f1Sync.future
    r2 <- f2Sync.future
    .. all your syncs
    rn <- fAsynchronous // this should also return a future
    rnn <- f50Sync(rn).future// you can even pass the result of the async to the next function
  } yield rn  
}

There is minimal boilerplate of converting your sync calls to immediately resolved futures. Don't be tempted to do that with Future.apply[T](t) or simply Future(a) as that will put daemon threads onto the executor. You won't be able to convert without an implicit executor.

With promises you pay the price of 3, 4 promises which is negligible and you get what you want. for yield acts as a sequencer, it will wait for every result in turn, so you can even do something with your async result after it has been processed.

It will "wait" for every sync call to complete as well, which will happen immediately by design, except for the async call where normal async processing will be automatically employed.

Upvotes: 1

Related Questions