Scala Future.sequence(Iterator) 抛出 NoSuchElementException

Question

Why is the following code throwing java.util.NoSuchElementException: next on empty iterator ???

     implicit val ec = ExecutionContext.global
     val it = (0 until 10).toIterator.map{
       x =>
         Thread.sleep(500)
         println(x)
         x
     }
     val it2 = new Iterator[Future[Int]] {
       def hasNext = it.hasNext
       def next() = Future { blocking { it.next() } }
     } //This should be equivalent to it.map{x => Future{blocking{x}}}
     Await.result(Future.sequence(it2), Inf)

Subsidiary question: why is it2 not behaving as it.map{x => Future{blocking{x}}} ??

Answer 1

You have a concurrency error, someone calls hasNext it returns true because the underlying iterator is capable of producing new elements. Then it calls next this returns a future that when completed will hold the next value.
However, for the caller (in this case Future.sequence ) it already finished so it calls hasNext again which will return true again but because the underlying iterator hasn't finished producing the first element so we produce a second that is enqueued until the first one finish (so you win nothing with the future) .

And this continues creating more and more and more futures that will eventually call next and get a NoSuchElementException because the underlying iterator didn't have more elements but you already create more and more futures waiting for more and more elements.
So, in other words, you are getting a true in hasNext just because it hasn't finished producing elements and as such haven't mutated its internal state; not because it actually has more elements.

This is a good recordatory that mutability + concurrency = headaches.
Again, I recommend you to use an appropriate abstraction for thi

Answer 2

The other answer is pointing to the right direction, but I just rephrase it a bit more cleanly. By adding some printouts in next() and hasNext methods, one can see that they are called continuously. This is because the it and it2 gets out-of-sync: it.next() is blocking, while it2.next() is not, but it2.hasNext == it.hasNext , so it2.hasNext is blocking. As a result it2 has its next() and hasNext out-of-sync which is a mess!