每个Scala Future最终都必须调用Await.result

Question

I am trying to learn Scala futures. As the title suggests, it seems to me that Await.result must eventually be called at some point in your program to get the value of a future extracted in to a Scala field. Here is my code so far. I am querying a arbitrary uri here and mapping it to a case class called Address suppose that this Address case class has one field, final_balance .

  case class Address(final_balance:Double) 
  def getAddress(bitcoinAddress: String)(format: DataFormat): Future[Address] = {

    val uri: String = "http://example.com"
    val response: Future[HttpResponse] = (IO(Http) ? HttpRequest(GET, Uri(uri))).mapTo[HttpResponse]

    implicit val addressJsonFormat = AddressJsonProtocol.addressFormat
    val address: Future[Address] = response.flatMap { x =>
      x match {
        case HttpResponse(_, entity, _, _) =>
          Future(entity.asString.parseJson.convertTo[Address])
      }
    }
    address
  }

  def getFinalBalance(address: String): Double = {
    val futureAddress: Future[Address] = QueryAddress.getAddress(address)(Json)
    val finalBalance:Future[Double] = for { a <- futureAddress } yield a.final_balance

   //block until the result can be determined
   Await.result(finalBalance, 15.second)


  }

Is this incorrect?

Answer 1

It is not the only way to get or do something with the underlying value/result from a Future[A] here are some other ways to consider:

Combinators

The point of future combinators is to be able to combine futures together before having to pull the underlying out from the end future. Deferring as long as possible is usually a good idea.

There is a recover combinator which will allow you to do something to deal with an exception occurring:

f1 recover {
  case e: ApiException => ...do something...
}

There is a fallbackTo combinator too:

f1 fallbackTo f2 // (if result of `f1` is failure case, then execute `f2`)

Now if you wanted the first future that completed to be the result returned, you could use the either combinator though it has interesting characteristics so read the docs and play with it in the REPL some to understand it better:

f1 either f2

There is also filter , foreach , and the two most obvious map , and flatmap . Another combinator you might want to use is zip which will "zip" results of two futures up as a tuple which you can then apply to a data/value constructor .

Also andThen can be use like this:

f1 andThen f2 // this defines order of execution (f1 and then f2 in this case)

Mapping (the most used combinator IME)

Yes, this doesn't get the underlying value out, but it can do something with the value:

val fUsers: Future[Int] = future {
  api.getConcurrentUsers
}

val fShouldCelebrate: Future[Boolean] = fUsers map { userCount =>
  (userCount >= 1000000)
}

// pass fShouldCelebrate around and use a method for extracting the underlying out when
// absolutely needed.

Via Callbacks

I don't necessarily recommend this approach, but it's one of the ways you can do something with the result of a Future[A] .

One example would be:

import scala.util.{Success, Failure}

// Not sure what a Response type is...but use your imagination :)
val response: Response = ???
val f: Future[List[String]] = future {
  db.getRecentPosts
}

f onComplete {
  case Success(posts) => for (p <- posts) response.render(p)
  case Failure(t) => response.error("An error has occured: " + t.getMessage)
}

Alternatively we can split the behavior out into the success and the failure cases separately:

import scala.util.{Success, Failure}

// Not sure what a Response type is...but use your imagination :)
val response: Response = ???
val f: Future[List[String]] = future {
  db.getRecentPosts
}

f onSuccess {
  case posts => for (p <- posts) response.render(p)
}

f onFailure {
  case t => response.error("An error has occured: " + t.getMessage)
}

For Comprehensions & Projections

Sometimes you have dependent future values, let's look at this example:

val ticker: String = "XYZA" // hopefully not a real ticker
val f1: Future[TickerQuote] = future { exchange1.getQuote(ticker) }
val f2: Future[TickerQuote] = future { exchange2.getQuote(ticker) }

val trade = for {
  q1 <- f1
  q2 <- f2
  if (q1 < q2)
} yield exchange1.buy(ticker, 100)

// obviously this is silly but hopefully you get the point?

If f1 or f2 failed then you can use the failed projection, something like this:

val f1: Future[Int] = future {
  throw new RuntimeException("whoops")
}
for (t <- f1.failed) response.error(t)

Await ing

Here we have Await.result and Await.ready blocking calls to get the underlying value out from a Future.

I don't recommend limiting yourself to Future[A] s. You should look at Scalaz's Task[A] construct, which I find to be much more flexible, intuitive (to me) and composable.

Further Reading

• SIP-14 - Futures and Promises (Note: I didn't cover promises at all, just use Scalaz Concurrent's Task[A] already;) I'm not opinionated at all.)
• The Neophytes Guide to Scala Part 9: Promises & Futures in Practice
• Scalaz Stream which uses scalaz.concurrent.Task

Answer 2

Eventually it must be called though, we cannot pass around a Future[T] forever, right?

We can - that is the beauty of Future :)

Since getFinalBalance , doesn't really need final_balance, let's change the code to return a Future.

def getFinalBalance(address: String): Future[Double] = {
  val futureAddress: Future[Address] = QueryAddress.getAddress(address)(Json)
  for { a <- futureAddress } yield a.final_balance
}

Now we're back to having a Future. What if we want to do something useful? Let's say we just want just print the balance it stdout. We can describe this using a function with this signature:

def printFinalBalance(balance: Future[Double]): Unit

To define this function, we could use Await.result, but we don't have to. We can use onComplete to register a call back function to be applied when the Future completes.

def printFinalBalance(fb: Future[Double]): Unit = 
  fb onComplete {
    case Success(balance) => println("Balance: " + balance)
    case Failure(e) => println("An error has occured: " + e.getMessage)
  }