Interaction with `java.util.concurrent.Future` is throwing weird `TimeoutException`

[fmndantas]

Compiler version

3.4.2

Minimized code

import java.util.concurrent.ExecutorService
import java.util.concurrent.Future
import java.util.concurrent.TimeUnit
import java.util.concurrent.Executors
import java.util.concurrent.Callable
import scala.util.Try
import scala.util.Success
import scala.util.Failure

type Par[A] = ExecutorService => Future[A]

def unit[A](a: A): Par[A] = _ => UnitFuture(a)

case class UnitFuture[A](get: A) extends Future[A] {
  def isDone = true
  def get(timeout: Long, units: TimeUnit) = get
  def isCancelled = false
  def cancel(evenIfRunning: Boolean): Boolean = false
}

def fork[A](a: => Par[A]): Par[A] =
  es =>
    es.submit(new Callable[A] {
      def call = a(es).get
    })

val es = Executors.newFixedThreadPool(5)
val par = fork(unit(10)) // this will work: val par = fork(es => UnitFuture(10))
val f = par(es)
val r = Try(f.get(1, TimeUnit.SECONDS))
r match
  case Success(v) => println(v)
  case Failure(e) => e.printStackTrace()

Output

java.util.concurrent.TimeoutException
        at java.base/java.util.concurrent.FutureTask.get(FutureTask.java:204)
        at com.github.fmndantas.seven.Seven$.$anonfun$2(Main.scala:165)
        at scala.util.Try$.apply(Try.scala:210)
        at com.github.fmndantas.seven.Seven$.<clinit>(Main.scala:165)
        at com.github.fmndantas.seven.Seven.main(Main.scala)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.base/java.lang.reflect.Method.invoke(Method.java:566)
        at sbt.Run.invokeMain(Run.scala:144)
        at sbt.Run.execute$1(Run.scala:94)
        at sbt.Run.$anonfun$runWithLoader$5(Run.scala:121)
        at sbt.Run$.executeSuccess(Run.scala:187)
        at sbt.Run.runWithLoader(Run.scala:121)
        at sbt.Defaults$.$anonfun$bgRunTask$6(Defaults.scala:2038)
        at sbt.Defaults$.$anonfun$termWrapper$2(Defaults.scala:1977)
        at scala.runtime.java8.JFunction0$mcV$sp.apply(JFunction0$mcV$sp.java:23)
        at scala.util.Try$.apply(Try.scala:213)
        at sbt.internal.BackgroundThreadPool$BackgroundRunnable.run(DefaultBackgroundJobService.scala:367)
        at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
        at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
        at java.base/java.lang.Thread.run(Thread.java:829)

Expectation

• Expected output: 10
• Scala compiler version 3.3.3 is working correctly

[Gedochao]

@fmndantas Can you provide more data about your build configuration?
Some extra questions which may help:

• Are you passing any options to the compiler?
• What version of SBT are you using?
• How exactly are you running it?
• What JVM are you running on?

The same code runs fine and returns 10 in Scala CLI on my machine (both with Scala 3.4.2 and 3.3.3).
I tried replicating it with SBT 1.10.0 and it seems to also work fine.

[bracevac]

I can reproduce this error when loading the example through the REPL. My setup: MacBook with M3 Pro CPU, macOS 14.5, Scala 3.4.2. The error persists across different JDK versions: OpenJDK 22, Oracle JDK 17,21 & 22.

[Gedochao]

Ok... so we have a reproduction. I wonder why it doesn't happen on my setup. 🤔

[bracevac]

I suspect there might be an initialization issue at the top level. This version wrapping the last six lines in a method executes just fine:

// ... as before
val es = Executors.newFixedThreadPool(5)
def run = 
  val par = fork(unit(10))
  val f = par(es)
  val r = Try(f.get(1, TimeUnit.SECONDS))
  r match
    case Success(v) => println(v)
    case Failure(e) => e.printStackTrace()

Then:

scala> :load future.scala
// defined alias type Par
  [A] = java.util.concurrent.ExecutorService => java.util.concurrent.Future[A]
def unit[A](a: A): Par[A]
// defined case class UnitFuture
def fork[A](a: => Par[A]): Par[A]
val es: java.util.concurrent.ExecutorService = java.util.concurrent.ThreadPoolExecutor@25d6ae3[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
def run: Unit

scala> run
10

[natsukagami]

Another "strange" input point: for me, running the file as scala-cli run test.sc prints 10 immediately, but hangs indefinitely after that. I tried on Scala 3.3.3, 3.4.1, 3.4.2 and on JVM 17/21, .

If loaded into the REPL (as the above comment), run returns immediately, but exiting the repl (with ctrl-d) will hang it.

Interestingly running it through --native has the same behavior.

I'm on NixOS x86-64, running scala-cli 1.3.1, JDK 17/21 from Nixpkgs (lightly patched OpenJDK, scala-cli provided JDKs don't work on NixOS).

[fmndantas]

@Gedochao, sorry; I missed my setup info:

• Ubuntu 24.04
• SBT 1.10.0
• The issue is reproducible through Scala REPL
• JVM 21 (Adoptium Open JDK). I think that's the JVM automatically installed by Coursier

[som-snytt]

It needs es.shutdown() to exit the JVM.

The repro steps are quite vague. Does "thru REPL" mean :load? etc. The OP is not ordinary source. So it depends on how the final expr is wrapped.

[bracevac]

Yes, I saved the example to a file (e.g., future.scala), invoked the REPL, and then loaded the file using :load future.scala.
The outcome is a java.util.concurrent.TimeoutException every time. Also, copy-pasting the example all at once into the REPL results in the same outcome.

The puzzling part is why val par = fork(unit(10)) results in the timeout, whereas inlining unit's body val par = fork(es => UnitFuture(10)) does not.

However, entering it line by line into a fresh REPL session (& being careful to move def unit[A](a: A): Par[A] = _ => UnitFuture(a) after the definition of case class UnitFuture), does not throw the exception and yields 10 as expected.