Shouldn't join resume after onCompletion?

Hello,

please consider the following code:

fun foo() {
  Thread.sleep(1000)
  println("alright this have been executed")
}

fun main(args: Array<String>) {
  val job = Job()

  job.cancel()

  GlobalScope.launch(job) {
    try {
      println("do stuff")
    } finally {
      foo()
    }
  }

  runBlocking {
    println("before join")
    job.cancelAndJoin()
    println("afterJoin")
  }
}

foo() is not invoked at all, because the job is cancelled before being scheduled.

So what are my options, if I want to make sure foo() is always executed?

One may try to use onCompletion like this:

fun foo() {
  Thread.sleep(1000)
  println("alright this have been executed")
}

fun main(args: Array<String>) {
  val job = Job()

  job.cancel()

  GlobalScope.launch(job, onCompletion = { foo() }) { println("do stuff") }

  runBlocking {
    println("before join")
    job.cancelAndJoin()
    println("afterJoin")
  }
}

But it doesn’t help, because join doesn’t seem to care if onCompletion have been executed or not.

And here comes my question: Shouldn’t join resume only after the execution onCompletion?

[elizarov]

Ops. We need to promote CoroutineStart.ATOMIC from internal to experimental.

[elizarov]

For now, start = ATOMIC with try / finally { ... } is the only guaranteed way to make sure that something is done before other coroutines that .join resume. In the future we might add back support or something similar to onCompletion, but it has to be composable (don’t want to hack every coroutine builder again).

Btw, if you are only interested in exceptions, you can install CorouinteExceptionHandler. It is guaranteed to be invoked before all joining coroutines can resume.