How to call multiple Uni concurrently

Recently, I'm working on a project where I have 2 make 2 asynchronous calls at the same time. Since I'm working with Quarkus, I ended up trying to make use of Mutiny and the vert.x library. However, I can not get my code working with Unis. In the below code, I would imagine that both Unis would be called and the Uni that returns fastest would be returned. However, it seems that when combining Unis it simply returns the first one in the list, even though the first uni should take a longer time.

The below code prints out one one when it should print out two two since the uniFast should finish first. How do I combine Unis and have the faster one return first?

@Test
    public void testUniJion(){
        var uniSLow = Uni.createFrom().item(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "one";
        });

        var uniFast = Uni.createFrom().item(() -> {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "two";
        });

        var resp = Uni.join().first(uniSLow,uniFast).withItem().await().indefinitely();
        System.out.println(resp);

        var resp2 = Uni.combine().any().of(uniSLow,uniFast).await().indefinitely();
        System.out.println(resp2);
    }

Note: This is not the actual code I am trying to implement. In my code, I am trying to fetch from 2 different databases. However, one database often has a lot more latency than the other. However, Uni seems to always wait for the slower database. I'm simply trying to understand Mutiny and Uni's better so I made this code example.

Solution

The problem is that you are not telling Mutiny on which thread should run each uni. If I add a System.out to your example:

// Slow and Fast for the different Uni
System.out.println( "Slow - " + Thread.currentThread().getId() + ":" + Thread.currentThread().getName() );

I get the following output:

Slow - 1:Test worker
one
Slow - 1:Test worker
Fast - 1:Test worker
one

The output shows that everything runs on the same thread and therefore when we block the first one, the second one is blocked too. That's why the output is one one.

One way to run the uni in parallel is to use a different executor at subscription:

ExecutorService executorService = Executors.newFixedThreadPool( 5 );
uniSlow = uniSlow.runSubscriptionOn( executorService );
uniFast = uniFast.runSubscriptionOn( executorService );

Now, when I run the test, I have the expected output:

Slow - 16:pool-3-thread-1
Fast - 17:pool-3-thread-2
two
Slow - 18:pool-3-thread-3
Fast - 19:pool-3-thread-4
two

Note that this time Slow and Fast are running on different threads.

The Mutiny guide has a section about the difference between emitOn vs. runSubscriptionOn and some examples on how to change the emission thread.