threadpoolexecutor

From java docs, A ForkJoinPool differs from other kinds of ExecutorService mainly by virtue of employing work-stealing: all threads in the pool attempt to find and execute subtasks created by other active tasks (eventually blocking waiting for work if none exist). This enables efficient processing when most tasks spawn other subtasks (as do most ForkJoinTasks). When setting asyncMode to true in constructors, ForkJoinPools may also be appropriate for use with event-style tasks that are never joined. After going through below ForkJoinPool example , Unlike ThreadPoolExecutor, I have not seen

CompletableFuture::supplyAsync(() -> IO bound queries) How do I chose an Executor for CompletableFuture::supplyAsync to avoid polluting the ForkJoinPool.commonPool() . There are many options in Executors ( newCachedThreadPool , newWorkStealingPool , newFixedThreadPool etc) And I read about new ForkJoinPool here How do I chose the right one for my use case ? You should use public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor) method. As executor you can use any from the Executors.new.. - it depends on your needs. It's better to use newFixedThreadPool()

We have a scenario where tasks submitted to ThreadPoolExecutor are long running. When the thread pool is started we start it with core pool size = 5, max pool size = 20 and queue size of 10. In our application around 10 tasks get submitted. Most of the time these tasks run for few mins/hrs and then complete. However there was a situation when all of the 5 tasks got hanged on I/O. As a result my core pool size reached it max, but my Threadpoolexecutor queue was not full. So the additional 5 tasks never got a chance to run. Please do suggest how we can handle such scenario? Is having a smaller

I'm using ThreadPoolTaskExecutor for executing my tasks which are implemantations of Callable interface. I just want to check in time if task is still in pool (monitoring). How to do that? I know that I can get queue from ThreadPoolExecutor but how can I cast Runnable to Callable? Basically I have this callable public interface IFormatter extends Callable<Integer>{ Long getOrderId(); } I'm executing it like this ThreadPoolExecutor.submit(new Formatter(order)); And finally I'd like to loop through queue of ExecutorService in some async method and check if thread with orderId is still there.

I have a queue of running threads and would like to expose some of its data while it is executed, to monitor the process. ThreadPoolExecutor provides access to its queue and I can iterate through these objects to call my overridden toString() method, but these are only threads that are waiting for execution. Is there a way to access threads that are currently running to call my method? Or maybe there's a better approach for this task in general? To clarify a bit more about the purpose, here's some code of general idea: public class GetDataTask implements Runnable { private String pageNumber;

The application conduction api calls in every 10seconds with the gps location from the network provider. And also there are several api calls can be do by the user. application is crashing with law internet or less internet connection(device data access) is there a proper way to prevent app crashing and hold the api request till the internet network available. here im posting my crash reprort stacktrace java.util.concurrent.RejectedExecutionException: Task android.os.AsyncTask$3@4206a5b0 rejected from java.util.concurrent.ThreadPoolExecutor@41e97858[Running, pool size = 9, active threads = 9,

My question is strongly related to this one here . As was posted there, I would like the main thread to wait until the work queue is empty and all tasks have finished. The problem in my situation is, however, that each task may recursively cause new tasks to be submitted for processing. This makes it a little awkward to collect all of those tasks's futures. Our current solution uses a busy-wait loop to await termination: do { //Wait until we are done the processing try { Thread.sleep(200); } catch (InterruptedException e) { throw new RuntimeException(e); } } while (!executor.getQueue().isEmpty

In my Android project I had a lot of places where I need to run some code asynchronously (a web request, call to db etc.). This is not long running tasks (maximum a few seconds). Until now I was doing this kind of stuff with creating a new thread, passing it a new runnable with the task. But recently I have read an article about threads and concurrency in Java and understood that creating a new Thread for every single task is not a good decision. So now I have created a ThreadPoolExecutor in my Application class which holds 5 threads. Here is the code: public class App extends Application {