Android - how to check if ThreadPoolExecutor has reached the queue limit?

Question

I use many AsyncTask classes in my app. I always start them using:

if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB ) {
    asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
} else {
    asyncTask.execute();
}

Recently I got a RejectedExecutionException exception. I read about this and understand why this happens (exceeding the maximum number of tasks that thread pool executor can have in its queue).

But i didn't read anywhere about a way to check if thread pool executor has available slots so that I can avoid this. From what I tested the asyncTask.execute(); method does not have this limitation.

So I'm looking for something like this:

if(executorCanHandlerAnotherQueue()){ 
    if( Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB ) {
        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
    } else {
        asyncTask.execute();
    } 
}
else{
    asyncTask.execute();
}

Any ideas on how to implement this with backwards compatibility up to API 9?

Answer 1

AsyncTask uses thread pool pattern, so it just provide a default number of thread. If you call execute(), the task will wait for a worker thread free to do.

To execute in a real parallel, you can call executeOnExecutor(). But it also is limited (maximum number of tasks = thread pool size + task queue size).

You can create a custom Executor to increase number of thread or task queue like this:

public static final Executor CUSTOM_THREAD_POOL_EXECUTOR
        = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

For running executor() function for Android lower than HONEYCOMB, you can use

AsyncTaskCompat.executeParallel(task, params);

from support v4 library.

You can find more details in this answer

UPDATE:

For checking executor available before execute, you can write a small function like that:

    boolean canExecutorAddAnotherQueue(ThreadPoolExecutor executor){
        int active = executor.getActiveCount();
        int corePoolSize = executor.getCorePoolSize();
        int poolSize = executor.getPoolSize();
        if (active < corePoolSize || active < poolSize) return true;
        int queueSize = executor.getQueue().size();
        if (queueSize < MAX_QUEUE_SIZE_YOU_DEFINED) return true;
        return false;
    }

But it maybe miss some cases that also accepted.

FINAL ANSWER:

So I found the best choice is using try catch:

        try {
            //execute asynctask
        } catch (RejectedExecutionException e){
            //Handle when has exception thrown
        }

Or using custom handler:

    public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

You can write your own handler for handling cases which the task is rejected, and not throw the RejectedExecutionException anymore.