Scala Future calling lazy method inside block is not working - scala

Question

Problem:
I am trying to call lazy function(function assigned to lazy val) inside Future block and it is not behaving as expected but when i execute the function directly inside the block it is working as expected. Not sure if am missing any.
Working Code:
Below is the code working as expected when i execute the method directly inside Future block
implicit val ec = ExecutionContext.fromExecutorService {
Executors.newFixedThreadPool(8)
}
def execute1() = {
Thread.sleep(4000); println("Completed 1!!!")
1
}
def execute2() = {
Thread.sleep(3000); println("Completed 2!!!")
2
}
def execute3() = {
Thread.sleep(2000); println("Completed 3!!!")
3
}
def execute4() = {
Thread.sleep(1000); println("Completed 4!!!")
4
}
val future1 : Future[Int] = Future.apply(execute1())
val future2 : Future[Int] = Future.apply(execute2())
val future3 : Future[Int] = Future.apply(execute3())
val future4 : Future[Int] = Future.apply(execute4())
val result = for { r1 <- future1
r2 <- future2
r3 <- future3
r4 <- future4
} yield {
println(r1+","+r2+","+r3+","+r4)
}
StdIn.readLine()
sys.exit()
When the above code is executed, the methods are executed in order "execute4,execute3,execute2,execute1" which is as expected.
Not Working Code:
In the above code, when i trying assigning the "execute" method to lazy variable and refer that variable inside Future block it is behaving differently. It is executed in 1,4,3,2 order.. Please see below code
implicit val ec = ExecutionContext.fromExecutorService {
Executors.newFixedThreadPool(8)
}
def execute1() = {
Thread.sleep(4000); println("Completed 1!!!")
1
}
def execute2() = {
Thread.sleep(3000); println("Completed 2!!!")
2
}
def execute3() = {
Thread.sleep(2000); println("Completed 3!!!")
3
}
def execute4() = {
Thread.sleep(1000); println("Completed 4!!!")
4
}
lazy val e1 = execute1()
lazy val e2 = execute2()
lazy val e3 = execute3()
lazy val e4 = execute4()
val future1 : Future[Int] = Future.apply(e1)
val future2 : Future[Int] = Future.apply(e2)
val future3 : Future[Int] = Future.apply(e3)
val future4 : Future[Int] = Future.apply(e4)
val result = for { r1 <- future1
r2 <- future2
r3 <- future3
r4 <- future4
} yield {
println(r1+","+r2+","+r3+","+r4)
}
StdIn.readLine()
sys.exit()
Expected Behavior: Since the functions(e1,e2,e3,e4) are referred as Lazy, it should be executed inside Future block upon calling and should behave same as the working code. Weird behavior i notice is it executes execute1() method synchronously and rest of the methods asynchronously.. Any guidance or suggestion will be great to me..
Output I am Expecting:
Regardless of "i execute the method inside Future block"(or) "make the method as lazy outside the Future block and call inside the Future block" should yield me the same result.. As per my example, the output i am expecting is "the order of method execution(asynchronously) as execute4(),execute3(),execute2() and execute(1)"
To simplify the example..
Future Execution is different in below two approach.. In both the approach, i am expecting same output
//Approach#1
def method() = {
}
Future{
method()
}
//Approach#2
lazy val lazyMethod = method()
Future {
lazyMethod()
}

Answer 1

Actually the code is working as expected. Let me explain.
First comes the for, when you did,
val result = for {
r1 <- future1
r2 <- future2
r3 <- future3
r4 <- future4
} yield {
println(r1+","+r2+","+r3+","+r4)
}
You are roughly doing,
val result =
future1.flatMap(r1 =>
future2.flatMap(r2 =>
future3.flatMap(r3 =>
future4.map(r4 =>
println(r1+","+r2+","+r3+","+r4)
)
)
)
)
Which means you are "accessing" the values computed by these futures only after you have accessed the value of the previous one.
Now comes the Future.apply which takes a body: => T as argument and gives you a Future[T] but the thing is that this body will start executing as soon as you create the future.
So, In your first implementation when you did,
val future1 : Future[Int] = Future.apply(execute1())
val future2 : Future[Int] = Future.apply(execute2())
val future3 : Future[Int] = Future.apply(execute3())
val future4 : Future[Int] = Future.apply(execute4())
All these futuresI's began executing your executeI's at this point. So, the println inside these executeI's will be executed x ms after this, irrespective of when you try to access the value inside any of these futures.
Now, comes the lazy. So when you declare something like this,
val laxy x = {
println("accessing lazy x")
5
}
The block will be executed only when you access x for the first time.
And when you are doing this,
val future1 : Future[Int] = Future.apply(e1)
val future2 : Future[Int] = Future.apply(e2)
val future3 : Future[Int] = Future.apply(e3)
val future4 : Future[Int] = Future.apply(e4)
You are still not "accessing" any of these lazy eI's but as you know that each future starts computing as soon as it is created. So when these futures start executing they will "access" these eI's.
To understand it better, lets change our executeI's as following,
def execute1() = {
println("Started 1!!! " + System.currentTimeMillis())
Thread.sleep(4000)
println("Completed 1!!! " + System.currentTimeMillis())
1
}
And you will notice that all of these eI's are executing sequentially.
This is because all these eI's will be evaluated in the thread where these were defined and not in the thread executing the Future. So these Thread.sleep will block the current thread and will be evaluated in a non-deterministic order (owing to some probable optimizations), which co-incidentally happens to be 1, 4, 3, 2.
But if you change the order of future to,
val future1 : Future[Int] = Future.apply(e1)
val future4 : Future[Int] = Future.apply(e4)
val future2 : Future[Int] = Future.apply(e2)
val future3 : Future[Int] = Future.apply(e3)
It will become 1, 3, 2, 4.