Thread-Pool | Thread pool implemented in C language

You associate the dispatcher with the actor when you spawn it, by passing an akka.actor.typed.DispatcherSelector (which extends akka.actor.typed.Props) corresponding to the desired dispatcher.

When spawning the ActorSystem on a custom dispatcher, one can only pass Props through the overloads that take either a Config or an ActorSystemSetup.

If wanting to override the actor for the user guardian actor (the actor with the behavior you passed into the ActorSystem), it may make more sense to make that dispatcher the default dispatcher:

From your problem statement - it looks like you have got a server application with which clients can interact by sending java objects using serialization binary protocol. Jmeter is generally not used for such testing as it generally caters to other well known protocols like http, jms, ftp etc. There are readily available samplers for these. However if you want to use java serilization your best bet it to perhaps use java sampler to write own request sending/response recieving code or to use a commercial plugin ( available for trial) like this.

Other alternative is to perhaps write your own test application and use statistics from there to create visualizations.

It is probably new threads yes. This is totally dependent of the platform and the OpenMP implementation. Moreover, this is unspecified by the OpenMP specification and so a compliant behavior. However, the GCC runtime (GOMP) and Intel/Clang one (IOMP) tend to reuse the threads as much as possible in practice. On my machine (with 6 cores), I am not able to reproduce your issue with both GOMP with GCC-10.2 and IOMP with Clang-11.0. Moreover, the following program show the same thread IDs which likely means they are reused:

Are you blocking in your calls? Eg, are you calling Thread.sleep? Or using some synchronous IO? If so, then what you're seeing is entirely expected.

Lagom is an asynchronous framework. All the IO and inter-service communication mechanisms it provides are non blocking. Its thread pools a tuned for non blocking. If you only using non blocking calls, you will see the thread pools behave with very low thread counts, and you won't find things going unresponsive.

But the moment you start blocking, all bets are off. Blocking requires one thread per request.

The default dispatcher that Akka uses is a fork join pool. It is designed for asynchronous use. If you block in a thread in its pool, it will start another thread to ensure other tasks can continue. So, that's why you see the thread pool grow. Don't block, and this won't happen.

The thread pool executor on the other hand uses a fixed number of threads. If you block on this, then you risk deadlocking the entire application. Don't block, and this won't happen.

Yes, it is possible to modify this code. Simply grab the source from the ActiveMQ Artemis GitHub repository and modify it as you need.

That said, it' unclear why you need to modify this code so it may not be a good solution to your problem.

In order to connect to Payara Server, the only effective way I found was creating a Connection Pool directly in the Domain Admin Console.

It may seem a long way now, but after completing it will become second nature:

Download MySQL8 Java Connector available at https://dev.mysql.com/downloads/connector/j/ and unzip to any folder:

It will extract to something like: mysql-connector-java-8.0.23 2/mysql-connector-java-8.0.23.jar

1) Make sure you have Payara Server up and running:

Is it better to create threads in the function which calls Hamil_vector_multiply and then pass a vector of threads to Hamil_vector_multiply in order to avoid creating each time new threads?

If your worried about performance, yes it would help. What your doing right now is essentially allocating a new heap block in every function call (I'm talking about the vector). If you can do it beforehand, it'll give you some performance. There isn't an issue doing this but you could gain some performance.

Would it be better to asynchronously attack the loop (for instance the first thread to finish an iterations starts the next available? If yes can you point to any literature describing threads asynchronously?

This might not be a good idea. You will have to lock resources using mutexes when sharing the same data between multiple threads. This means that you'll get the same amount of performance as processing using one thread because the other thread(s) will have to wait till the resource is unlocked and ready to be used.

Are there maybe better ways of multithreading such a loop? (without multithreading i have a loop from k=0 to k=N=8^14, which takes up a lot of time)

If your goal is to improve performance, if you can put it into multiple threads, and most importantly if multithreading will help, then there isn't a reason to not doing it. From what I can see, your implementation looks pretty neat. But keep in mind, starting a thread itself is a little costly (negligible when compared to your performance gain), and load balancing will definitely improve performance even further.

But if you have other helpful comments not regarding multithreading I woul be grateful for every piece of advice

If your load per thread might vary, it'll be a good investment to think about load balancing. Other than that, I don't see an issue. The major places to improve would be your logic itself. Threads can do so much if your logic takes a hell of a lot time..

Optional:
You can use std::future to implement the same with the added bonus of it starting the thread asynchronously upon destruction, meaning when your thread pool destroys (when the vector goes out of scope), it'll start the threads. But then it might interfere with your first question.

The event loop is not something you start up by yourself, or write yourself. In webflux the event loop is created by the underlying webserver (netty) that runs a couple of event loops depending on how many cores the host has.

I can't see any way of running 2 different webserver implementations underneath at the same time on a single application. Im not sure and someone from the spring team needs to answer the more specifics here.

Tbh, if this is a big and important project, i'd keep the original server, and then by using a load balancer infront, start out by duplicating the requests and send them to both services and implement an endpoint, run it in parallell for a while to se that it works good, and then switch off the parallell running. And do this for each/a couple of endpoint at the time.

There are also specific shadowing tools for this purpose like goreplay.

You want callback hell? That's a new one.

from what I can understand, is more akin to Scala's promises, and is not tied to a thread-pool.

Incorrect. I think CompletableFuture is precisely what you want :)

There is a default executor that will be used, but you can also specify one explicitly if you prefer - the supplyAsync and runAsync methods have overloads where you can pass in an explicit executor instead, and all the stuff in the chain uses whatever the future you're chaining off of uses.