CompletableFuture anyOf

So earlier I had my exam, and there was this question.

> ### Question 5: Asynchronous Programming (8 points)
> Consider the program below. The method doSomething ( ) may run for an undeterministic amount of time.
>
> import java.util.concurrent.CompletableFuture;
> class CF {
> static void doSomething() { .. }
>
> static CompletableFuture<Void> printAsync(int i) {
> return CompletableFuture.runAsync(() -> {
> doSomething();
> System.out.print(i);
> });
> }
>
> public static void main(string[] args) {
> CompletableFuture.anyof(
> printAsync(1)
> .thenRun(() -> printAsync(2)),
> printAsync(3))
> .thenRun(() -> printAsync(4));
> dosomething();
> }
> }
>
> What are the possible outputs printed by the program if main runs to completion normally?
>
> Fill in the blank with the string yes if a given output is possible. Fill in the blank with the string no if main will never print the given output.
> Note that this question will be graded by a bot. So, filling in with any other text, such as "NO!", "yes, because ..", "never!", etc, will lead to the answer being marked as wrong even if the intention of the answer is correct.
>
> (a) 1
> (b) 2
> (c) 3
> (d) 4
> (e) 12
> (f) 14
> (g) 23
> (h) 24
> (i) 124
> (j) 134
> (k) 243
> (l) 234
> (m) 213
> (n) 1324
> (o) 4321

My question is for CompletableFuture.anyOf. When one of the processes finish, does the other process finish to completion even after the other thenRun is running or does it terminate prematurely?

anyOf only creates a new future allowing to schedule other operations, to be performed when at least one of the specified futures has been completed. It does not influence any of its arguments.

But note that the main method only uses it to chain another operation, without waiting for the completion of any future. It just performs another doSomething(), which takes an intentionally unspecified time. Then, the main method returns, and in the standard environment, the JVM will terminate when it detects that only daemon threads exist.

Since this JVM termination does not care for any of the background operations, there is no guaranty about any completion. In principle, even no output is possible.

But the chained operations define dependencies, which are obeyed.

1. 1 → 2. Therefore, you will never see a 2 without a 1 in the output. And when both numbers are present, 1 must be before 2.
2. (1 → 2 | 3) → 4. If you see 4, at least either of 2 or 3 must be there, and it must be before 4. When it is 2, the first point applies too. But note that when both, 2 and 3, are present, only one of them is required to be before the 4, so 3412 would be a valid output.

Besides these rules, the order can be arbitrary, and, as said, the completion is not guaranteed. You could see a sole 1 or a sole 3, or 1 and 3 in arbitrary order. But, as explained above, you can’t see a sole 2 nor a sole 4. You can go through every suggested answer and check if it violates one of the dependencies. If not, it’s a possible outcome.