Composing suspending functions
This section covers various approaches to composition of suspending functions.
Sequential by default
Assume that we have two suspending functions defined elsewhere that do something useful like some kind of remote service call or computation. We just pretend they are useful, but actually each one just delays for a second for the purpose of this example:
What do we do if we need them to be invoked sequentially — first doSomethingUsefulOne
and then doSomethingUsefulTwo
, and compute the sum of their results? In practice we do this if we use the result of the first function to make a decision on whether we need to invoke the second one or to decide on how to invoke it.
We use a normal sequential invocation, because the code in the coroutine, just like in the regular code, is sequential by default. The following example demonstrates it by measuring the total time it takes to execute both suspending functions:
It produces something like this:
Concurrent using async
What if there are no dependencies between invocations of doSomethingUsefulOne
and doSomethingUsefulTwo
and we want to get the answer faster, by doing both concurrently? This is where async comes to help.
Conceptually, async is just like launch. It starts a separate coroutine which is a light-weight thread that works concurrently with all the other coroutines. The difference is that launch
returns a Job and does not carry any resulting value, while async
returns a Deferred — a light-weight non-blocking future that represents a promise to provide a result later. You can use .await()
on a deferred value to get its eventual result, but Deferred
is also a Job
, so you can cancel it if needed.
It produces something like this:
This is twice as fast, because the two coroutines execute concurrently. Note that concurrency with coroutines is always explicit.
Lazily started async
Optionally, async can be made lazy by setting its start
parameter to CoroutineStart.LAZY. In this mode it only starts the coroutine when its result is required by await, or if its Job
's start function is invoked. Run the following example:
It produces something like this:
So, here the two coroutines are defined but not executed as in the previous example, but the control is given to the programmer on when exactly to start the execution by calling start. We first start one
, then start two
, and then await for the individual coroutines to finish.
Note that if we just call await in println
without first calling start on individual coroutines, this will lead to sequential behavior, since await starts the coroutine execution and waits for its finish, which is not the intended use-case for laziness. The use-case for async(start = CoroutineStart.LAZY)
is a replacement for the standard lazy
function in cases when computation of the value involves suspending functions.
Async-style functions
We can define async-style functions that invoke doSomethingUsefulOne
and doSomethingUsefulTwo
asynchronously using the async coroutine builder with an explicit GlobalScope reference. We name such functions with the "...Async" suffix to highlight the fact that they only start asynchronous computation and one needs to use the resulting deferred value to get the result.
Note that these xxxAsync
functions are not suspending functions. They can be used from anywhere. However, their use always implies asynchronous (here meaning concurrent) execution of their action with the invoking code.
The following example shows their use outside of coroutine:
Consider what happens if between the val one = somethingUsefulOneAsync()
line and one.await()
expression there is some logic error in the code and the program throws an exception and the operation that was being performed by the program aborts. Normally, a global error-handler could catch this exception, log and report the error for developers, but the program could otherwise continue doing other operations. But here we have somethingUsefulOneAsync
still running in the background, even though the operation that initiated it was aborted. This problem does not happen with structured concurrency, as shown in the section below.
Structured concurrency with async
Let us take the Concurrent using async example and extract a function that concurrently performs doSomethingUsefulOne
and doSomethingUsefulTwo
and returns the sum of their results. Because the async coroutine builder is defined as an extension on CoroutineScope, we need to have it in the scope and that is what the coroutineScope function provides:
This way, if something goes wrong inside the code of the concurrentSum
function and it throws an exception, all the coroutines that were launched in its scope will be cancelled.
We still have concurrent execution of both operations, as evident from the output of the above main
function:
Cancellation is always propagated through coroutines hierarchy:
Note how both the first async
and the awaiting parent are cancelled on failure of one of the children (namely, two
):