Question

I have to launch 10 tasks asynchronously at variable times through out the day until a certain hour the next day. The closer I get to the time the next day the more I have to repeat these 10 tasks.

My question, is how should I manage this? What executors should I use? What is the best way to manage the memory?

I thought of using an Executors.newScheduledThreadPool that could start a threadpool process with the 10 tasks at variable times. The problem requires me to launch a new set of tasks even though the previous group of tasks have not finished (so probably trigger a new threadpool each time).

I am also thinking of using sort of process registry to manage the different processes that have been launched. When a process is unused anymore than the registry can stop it.

And each time the tasks are done, I thought of flushing the runnables, and stopping the threadpool. Is that overall a good solution?

The problem that may arise, is to have the memory saturated with threadpools. Maybe put a time limit on the threadpool?

Answer 1

I guess, you need one dispatching thread inside plain non-scheduling pool and another pool for workers, something like this:

    ExecutorService ex = Executors.newFixedThreadPool(1);
    final ExecutorService workersPool = Executors.newCachedThreadPool();

    ex.submit(new Runnable() {
        public void run() {
            try {
                do { 
                    // determine if it's time to start workers
                    if (timeToStartWorkers()) {
                        workersPool.submit(new Worker(...));
                        workersPool.submit(new Worker(...));
                        ...
                    }
                    // sleep till next time
                    Thread.sleep(timeTillNextCheck);
                }
            } catch (InterruptedException e) {
                // handle exception
            }
        }
    });

No need to recreate thread pools.