0

I am new to concurrency and threading in java and I have this following scenario -

Function1(fetches next task from a queue and calls function2 with task) then Function2(calls Function Run to run this task) then Run(function run is submiting task using executor service which has a fixed thread pool and code is like below)

    ExecutorService exeService = Executors.newFixedThreadPool(3);
         private void run(Task task){
                    Abstract batchExecutor = getBatchExecutor(param1,param2, param3, param4, task);
                    Future<Void> future = exeService.submit(batchExecutor);
                    while (!future.isDone()) {
                        if (isStopRequested.get()) {
                            try {
                                future.get(5, TimeUnit.MINUTES);
                                } catch (TimeoutException e) {
                            e.printStackTrace();
                        }
                        throw new InterruptedException("message");
                    }
                            Thread.sleep(3000);
                    }
                        future.get();
                   Map<String, Result> submittedObjects = batchExecutor.getSubmittedObjects();
                   storeSubmittedObjects(submittedObjects);
        }

My problem is even after declaring a thread pool also tasks are still running in sequential way. How can I make it parallel so that as soon as there is another call to the run it should use free thread from pool and submit the task?

There is no return type for all these functions.

TheOnlyKiller
  • 13
  • 3

1 Answers1

2

The run(Task task) method contains future.get(); at the end: this means that your current thread will block until the submitted operation is completed. Hence if you make 3x calls to run(Task task) in same thread then all 3 tasks will execute sequentially not in parallel.

How to handle this properly rather depends on how you structure your application. If you don't submit huge number of tasks you could return the future from the method:

private Future<Void> run(Runnable task){
    Abstract batchExecutor = getBatchExecutor(param1,param2, param3, param4, task);
    return exeService.submit(batchExecutor);
}

Then scan the results later:

ArrayList<Future<Void>> pending = new ArrayList<>();
pending.add(run(task1));
pending.add(run(task2));
pending.add(run(task3));
// ...

// clean up background tasks
for (Future<?> fut : pending)
{
    fut.get();
}

Note that if you don't use results of the future, you can omit collecting pending and the above loop. Just ensure that your app closes the executor queue after all tasks are completed:

exeService.shutdown();
exeService.awaitTermination(365, TimeUnit.DAYS);

If you need to perform post processing after each task, your run(Task) method should change to use exeService.submit(Callable<SomeResult - such as Abstract>) and return Future<SomeResult> so that you can perform follow on actions in the calling thread later.

DuncG
  • 12,137
  • 2
  • 21
  • 33
  • Thank you for the answer but after future.get() also some computations are done using the abstract object. So, returning the future object will not work here. The future.get() also will not block as there is already a loop in place for that to check if the future is done or not. But i think that also is causing this to run sequentially. – TheOnlyKiller Jan 20 '22 at 04:43
  • The loop is part of the problem and is wholly pointless when followed by `future.get()`. Both block until task is finished but your loop could take up to 3 seconds longer than just calling `future.get()`. Just make the future return the abstract object then you can operate on it afterwards. – DuncG Jan 20 '22 at 09:38