java-thread | Java多线程编程学习，三本书和两套视频教程的学习

The access to the elements is thread-safe but not the usage of them. Two threads get access to the same element (one after the other) and both are calling methods on the element after that. The collection would not even know.

You can call AsyncTask.get() to get the result back after doInBackground completes.

what the putValue exactly does

It just sets a property of the Action.

Read the section from the Swing tutorial on How to Use Actions for more information and a list of all the properties.

When you add an Action to a Swing component (JButton, JMenuItem etc), The the properties of the Action are used to configure the component. So the same "text" can be used on all components, the "enabled" state will be the same for all components etc.

In the case of the mnemonic property a Key Binding will be set up automatically so that you can invoke the Action when the KeyStroke is used. Read the section from the Swing tutorial on Key Bindings

A voluntary context switch usually means a thread is waiting for something, e.g. for a lock to become free.

async-profiler can help to find where context switches happen. Here is a command line I used:

Uncommon traps and deoptimization are HotSpot implementation details. You won't find them in a standard interface like JVM TI (which is designed for a generic virtual machine, not just HotSpot).

As suggested in my previous answer, one possible way to diagnose deoptimization is to add -XX:+UnlockDiagnosticVMOptions -XX:+LogCompilation options and to look for in the compilation log.

Another approach is to trace deoptimization events with async-profiler.
To do so, use -e Deoptimization::uncommon_trap_inner.
This will show you the places in Java code where deoptimization happens, and also timestamps, if using jfr output format.

Since JDK 14, deoptimization events are also reported natively by Flight Recorder (JDK-8216041). Using Event Browser in JMC, you may find all uncommon traps, including method name, bytecode index, deoptimization reason, etc.

The overhead of all the above approaches is small enough. There is usually no problem in using async-profiler in production; JFR is also fine, if the recording settings are not superfluous.

However, there is no much use in profiling deoptimizations, except for very special cases. This is absolutely normal for a typical Java application to recompile methods multiple times, as long as the JVM learns more about the application in runtime. It may sound weird, but uncommon traps is a common technique of the speculative optimization :) As you can see on the above pictures, even basic methods like HashMap.put may cause deoptimization, and this is fine.

This is solved after changing the location of the log file from /SHARED to local

OLD :

The first reference you should check is the documentation.

Right from the documentation for ThreadPoolExecutor (ThreadPoolTaskExecutor is "just" a wrapper):

A ThreadPoolExecutor will automatically adjust the pool size (see getPoolSize()) according to the bounds set by corePoolSize (see getCorePoolSize()) and maximumPoolSize (see getMaximumPoolSize()). When a new task is submitted in method execute(Runnable), if fewer than corePoolSize threads are running, a new thread is created to handle the request, even if other worker threads are idle. Else if fewer than maximumPoolSize threads are running, a new thread will be created to handle the request only if the queue is full. [...]

If the pool currently has more than corePoolSize threads, excess threads will be terminated if they have been idle for more than the keepAliveTime (see getKeepAliveTime(TimeUnit)). This provides a means of reducing resource consumption when the pool is not being actively used. If the pool becomes more active later, new threads will be constructed. [...]

(You haven't mentioned the parameter for the BlockingQueue but I suggest you to read about it as well. It's very interesting.)

Why do the parameters not work like you've suggested they should?

If the pool size would be increased up to maximumPoolSize before tasks are queued (like you've proposed), you'd have one problem: You'd have removed the thread pool's ability to determine when a new worker is worth it.

The corePoolSize is the amount of workers that stay in the pool. The benefit is that you don't have to create, terminate, create, terminate, create ... new workers for a given workload. If you can determine how much work there will always be, it's a smart idea to set the corePoolSize accordingly.

The maximumPoolSize determines the maximum amount of workers in the pool. You want to have control over that as you could have multiple thread pools, hardware restrictions or just a specific program where you don't need as many workers.

Now why does the work queue get filled up first? Because the queue capacity is an indicator for when the amount of work is so high, that it's worth it to create new workers. As long the queue is not full, the core workers are supposed to be enough to handle the given work. If the capacity is reached, then new workers are created to handle further work.

With this mechanism the thread pool dynamically creates workers when there is a need for them and only keeps so many workers as there is usually need for. This is the point of a thread pool.

I realized a solution should probably allow all threads to submit new tasks recursively, which led me to this answer.

Here's a fully-fleshed version of that answer that handles traversal of a binary tree, obtained by starting from some string and roughly halving it. To support priorities one can simply modify MyTask.run() to pop the string from some auxiliary PriorityBlockingQueue, I decided to omit this because it just clutters the essence of the solution.

Threads share the cpu of the parent process. If we have 5 threads that doesn't mean we can make use of all 5 cores we got, each thread will the share the cpu/core of the main parent process. In your case 10 threads were sharing 100% cpu so you got 10% to each. Now each thread is running a python code with 10% cpu hence that is the computing power you got for python. I suggest you to do multi processing instead of multithreading. Like, each java process starts a python process and you can deploy multiple instances of java.