async-http-client | A fast async http client based on netty | HTTP library

You will need to change the encoding of the path segments in the parsed URI to a more strict one:

Future#sequence should execute the HTTP requests in parallel?

First of all, Future#sequence doesn't execute anything. It just produces a future that completes when all parameters complete. Evaluation (execution) of constructed futures starts immediately If there is a free thread in the EC. Otherwise, it simply submits it for a sort of queue. I am sure that in the first case you have single thread execution of futures.

println(scala.concurrent.ExecutionContext.Implicits.global) -> parallelism = 6

Don't know why it is like this, it might that other 5 thread is always busy for some reason. You can experiment with explicitly created new EC with 5-10 threads.

The difference with the Async case that you don't create a future by yourself, it is provided by the library, that internally don't block the thread. It starts the async process, "subscribes" for a result, and returns the future, which completes when the result will come.

Actually, async lib could have another EC internally, but I doubt.

Btw, Futures are not supposed to contain slow/io/blocking evaluations without blocking. Otherwise, you potentially will block the main thread pool (EC) and your app will be completely frozen.

They're orthogonal concepts, so that's why you don't see them mentioned in the same answers.

The aim of AsyncHttpClient is (among other things) to use a single thread for all network communication (performed internally by Netty through Java's NIO in a non-blocking asynchronous way), instead of the traditional thread-per-request model. On top of the network layer's single thread, the library has worker threads that perform the application level asynchronous handling visible to the users of AsyncHttpClient, meaning it already has a (small) internal pool of threads.

ForkJoinPool strives to maximize CPU usage by having many threads (the common pool has by default CPU cores - 1, ones you create can have more/less) and through work stealing so the threads aren't idle, and this is most efficient with small recursive tasks.

The link discusses that work stealing is also efficient with non-recursive tasks. The word "async" threw you off there, but it's just referring to a regular task that you submit to a pool, and it finishes asynchronously.

So you can either do thread-per-request (i.e. Basic I/O, or "old I/O") with a thread-pool, or you can use single threaded non-blocking NIO (i.e. New I/O) without a thread-pool.

Combining them doesn't make sense. You would migrate from a thread-per-request model to a non-blocking model to improve performance.

I’m afraid that at the moment you do need to make a new request from your delegate. Currently there is no way to automatically send a new request.