eclipse-collections | Eclipse Collections is a collections framework for Java with optimized data structures and a rich, f | Functional Programming library

Sounds like you want and need to create a runnable/ executable JAR file (with external dependencies).

This requires your build process to be enhanced by this step, regardless of where it is executed Heroku, Jenkins, Bamboo or on your local - this is a maven setting and will affect each of them.

Also on your local you can run the build of your project by executing mvn clean package in your IDE and afterwards to run the created JAR from the target folder with: java -jar ${yourJarName}. It'll likely fail for the same reason.

This is, because Maven dependencies are added with a so called scope. These are for example:

• compile
• provided
• runtime
• test

Whereby compile is the default one and being implicitly applied in case you don't specify it - like in your case. (You can read more about the scopes here)

This means Maven will add your dependency to your IDE at compile time, but it will be missing at the runtime, when your trying to execute it.

The solution is to create a runnable/ executable JAR file (also called *fat JAR *) containing all the needed dependencies.

You can do it directly within Maven with the help of the maven-assembly-plugin like so:

Look at this: in mvn install:install-file command you wrote version=0.0.1-SNAPSHOT, whereas in pom.xml I see 0.5.4-SNAPSHOT.

However, how does this work with threads spanning other threads and waiting (i.e. blocked until thread.join() is successful) for these 'subthreads'?

Threads will block, and it is up to the os/jvm to schedule another one if possible. If you have a single thread pool executor and call join from one of your tasks, the other task won't even get started. With executors that use more threads, then the blocking task will block a single thread and the os/jvm is free to scheduled other threads.

These blocked threads should not consume CPU time, because they are blocked. So I am assuming that for a CPU with N cores there is a rule of thumb that everything can be parallelized if the highest number of active threads (24) is #CPU + 1. Is this correct?

Active threads can be blocking. I think you're mixing terms here, #CPU, the number of cores, and the number of virtual cores. If you have N physical cores, then you can run N cpu bound tasks in parallel. When you have other types of blocking or very short lived tasks, then you can have more parallel tasks.