#Scala future how to
#Scala future code

This code is similar to the previous example, but this Future is wired to throw an exception about half the time, and the onSuccess and onFailure blocks are defined as partial functions they only need to handle their expected conditions. I created the sleep method in my package object while creating my future and concurrency examples, and it just calls Thread.sleep, like this:ĭef sleep(time: Long) ') You won’t need this in real-world programs, but in small example programs like this, you have to keep the JVM running.

The sleep statement at the end of the code is used so the program will keep running while the Future is off being calculated.

If the Future doesn’t return within that time, it throws a.

The Await.result method call declares that it will wait for up to one second for the Future to return.

This is the code that will be executed at some point in the future. Creating a Future is simple you just pass it a block of code you want to run.

A Future is created after the second comment.

The import statement imports the “default global execution context.” You can think of an execution context as being a thread pool, and this is a simple way to get access to a thread pool.

The import statements bring the code into scope that’s needed.

3 - this is blocking (blocking is bad) Implicit val baseTime = System.currentTimeMillis When it’s finished with the calculation, it returns its result: The following code performs the calculation 1 + 1 at some time in the future.

#Scala future how to

This first example shows how to create a future and then block to wait for its result.īlocking is not a good thing - you should block only if you really have to - but this is useful as a first example, in part, because it’s a little easier to reason about, and it also gets the bad stuff out of the way early. The following examples show a variety of ways to create futures and work with their eventual results.

Implicits, macros, and type-level programming are double-edges swords, and have been abused in the past. In Scala, it’s said that a future returns “eventually.” Kotlin seems more polished, but IMO is more of a local maximum, whereas Scala is rough around the edges, but ultimately a better way of programming. A future starts running concurrently when you create it and returns a result at some point, well, in the future. SolutionĪ Future gives you a simple way to run an algorithm concurrently. For instance, you may want to make several web service calls in parallel, and then work with their results after they all return. You want a simple way to run one or more tasks concurrently in a Scala application, including a way to handle their results when the tasks finish. This is Recipe 13.9, “Simple concurrency with Scala Futures.” Problem This is an excerpt from the Scala Cookbook (partially modified for the internet). show more info on classes/objects in repl.