Java – how to make the callable task submit to executorservice timeout

I submit the callable task (using submit()) to the implementation of executionservice Occasionally I seem to encounter a deadlock, but I can't where or why this happens, so I want to set a timeout on the task. I don't know how it does it?

Should I

>When submitting tasks and setting timeouts, use invokeany() instead of submit() on the executionservice I use submit() to submit many tasks one at a time. I'm cautious about whether I can use invokeany() like this, because I can't understand why there is no timeout submit() method. > Modify keepalivetime in the constructor of my executorservice (but I think it's doing something else) > modify my actual callable implementation, but if it's deadlock, it can't unlock itself

Option 1 seems to be the only viable solution, but what is it?

More details

I think if it helps the solution, you may need to explain in more detail how the process works

Task P1 can be called to start and work on the folder and all files and folders in it, and start grouping songs. It runs in executorservice Es1, and only one P1 instance is submitted to Es1

We also have three other callable classes: P2, P3, and P4 – each class has its own related executor service (ES2, Es3, Es4) Once P1 creates a group, it will submit a task to the relevant es and pass the group as data, that is, it can submit an instance of P2 to E2, P3 or P3 or P4 to E4. Which one it chooses depends on the details Grouping, P2, P3 and P4 all do different things

Assuming that it has submitted an instance of P2, P2 will complete the processing by submitting P3 to E3 or P4 to E4 Its one-way pipeline P3 can only be submitted to P4. Once all tasks are submitted to P4, P4 completes all tasks completed

We build ES1, ES3 and ES4 to complete the processing, submit the task to P1, and then call shutdown () in every ExecutorService, so that after P1 submits all the groups, shutdown () will not return, and then call shutdown () on ES2 until the ES2 clears its task queue.

Everything just stops. I assume that some processes prevent other processes from continuing, so at this time, I want a way to cancel the process. This process takes too long so that others can continue, which is far from being suspended indefinitely

Answer update

I try invokeany () as suggested, which works a bit If P1 submits a P2 instance to E2, it will wait before completion, which is good, because when using submit(), it only returns any way it does not handle further, but there are two problems:

>Each executorservice uses a bounded queue of 500. The idea is that if P2 is much slower than P1, we won't stack content on ES2 and eventually run out of memory Therefore, P1 is not completed until the task they call is completed, and the queue is actually smaller, because they not only include tasks waiting for the slot on ES2 to complete, but also include tasks that have been submitted to ES2 but are waiting for it to complete. > The pipeline is linked, so if we use invokeany on the task submitted from P1 and submit the task from P2, P3 and P4, when the task is submitted from P1 to P2, it will not return until the subsequent processing is completed from E4!

Solution

You can use guava's moreexecutors listening executorservice It won't magically solve your problem, but it can help:

1) You can set a timeout for each callable called through invokeall If the callable is not completed within a given time, it should be killed

2) You can create global mappings for all listenablefutures, each of which will register a flag at creation time and clear the flag at completion In this way, you can know what will not be completed in the future and help narrow the scope of the problem