``` val one = GlobalScope.async(start = CoroutineStart.LAZY) { A() } val two = GlobalScope.as...

# coroutines

[Hexa]

val one = GlobalScope.async(start = CoroutineStart.LAZY) { A() }
    val two = GlobalScope.async(start = CoroutineStart.LAZY) { B() }

    one.start()
    Thread.sleep(1000)
    two.start()

is there a better way to wait for one to start first before starting two without using Thread.sleep in between?

[spand]

If you want to wait for two to start until A() is done then you can just do one.join()

[spand]

ie:

val one = GlobalScope.async() { A() }
one.join()
val two = GlobalScope.async() { B() }

[Hexa]

thanks, but i dont necessarily want to wait for A() to be done. I just want to guarantee that two will start only after one has started

[spand]

Then I would suggest one to signal back using a CompletableDeferred.complete that you can join on then

[uli]

What do you mean by start? When do you consider A started?

[uli]

You might want to start A undispatched

[streetsofboston]

What is your use-case?
And when exactly do you consider { A() } to be started?
You'd need a third object that would allow your code to coordinate/synchronize the two.

[hallvard]

You could have one start two maybe? Since one should be in a good position to know exactly when `two`is to be started.

[uhe]

Usually in that case you would indeed use start = CoroutineStart.UNDISPATCHED, as Uli already said.
I don't think you can use LAZY and then start UNDISPATCHED later, though.

[Hexa]

In the end I just had one started two like @hallvard said