MyThreadPool | A simple threadpool implemented by C

The problem with it is that I expected every thread to execute in almost no time

Right. You're ignoring the fact that creating a new thread is a relatively expensive operation. Far, far more expensive than "acquiring a lock and incrementing an integer" which is the work you're doing in the thread.

To give a real world comparison, it's a little like ordering a new car, waiting it to be delivered, and then driving it 1km. That's going to be slower than just walking 1km.

Using the thread pool would be faster, but you're not using it correctly - you're launching one thread pool task which then creates all the other threads again.

I would encourage you to look at using Task instead, which normally uses the thread pool under the hood, and is a generally more modern abstraction for this sort of work.

Regarding the problems about the fact that QThreadPool::start() is not a virtual function, you can do something like this:

Instead of overriding a function, you can use your subclass in MyTask and use a different function that will call run. Something like this:

I don't know exactly your case, but easiest way - use OkHttp API to configure concurrency level, for example, this is default concurrency strategy of OkHttp

But you can have own strategy if you set own Dispatcher instance to OkHttpClient.Builder

Of course, you can use also coroutines

Your current implementation is incorrect because you create coroutines dispatcher for each item, but to have shared pool of threads all the coroutines should use the same dispatcher, just move newFixedThreadPoolContext creation outside of the loop (now you have 1000 dispatchers each with 10 threads).

But I don't recommend you to use coroutines + blocking calls, better to configure OkHttp concurrency (it's more flexible) and use coroutines with non-blocking calls (you can write own adapter or use an existing library like kotlin-coroutines-retrofit). It will allow you to mix your http requests and UI code or other tasks.

So if you use non-blocking API + OkHttp internal concurrency, you don't need to have special code to control concurrency, of course, you can limit the number of concurrent calls like in your example above (with fixed dispatcher construction), but I really don't think that it makes much sense, because you can decrease concurrency level, not increase it.

After moving to non-blocking API you can just run all your coroutines in any coroutines dispatcher in parallel (even in UI thread) and wait for results without blocking.

Also, implicit control of concurrency using OkHttpClient configuration looks as a more right way in terms of architecture (you can have DI code that configures Retrofit + OkHttp and provides it to your client code with preconfigured concurrency policy). Of course, you can achieve that using other approaches, but this one looks more natural for me.

You are calling OnThreadDone immediately after creating the thread, without waiting for it to complete: